alibabacloud-ecd20201002 1.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- alibabacloud_ecd20201002/__init__.py +1 -0
- alibabacloud_ecd20201002/client.py +2955 -0
- alibabacloud_ecd20201002/models.py +5279 -0
- alibabacloud_ecd20201002-1.1.0.dist-info/LICENSE +13 -0
- alibabacloud_ecd20201002-1.1.0.dist-info/METADATA +70 -0
- alibabacloud_ecd20201002-1.1.0.dist-info/RECORD +8 -0
- alibabacloud_ecd20201002-1.1.0.dist-info/WHEEL +5 -0
- alibabacloud_ecd20201002-1.1.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,2955 @@
|
|
|
1
|
+
# -*- coding: utf-8 -*-
|
|
2
|
+
# This file is auto-generated, don't edit it. Thanks.
|
|
3
|
+
from typing import Dict
|
|
4
|
+
from Tea.core import TeaCore
|
|
5
|
+
|
|
6
|
+
from alibabacloud_tea_openapi.client import Client as OpenApiClient
|
|
7
|
+
from alibabacloud_tea_openapi import models as open_api_models
|
|
8
|
+
from alibabacloud_tea_util.client import Client as UtilClient
|
|
9
|
+
from alibabacloud_endpoint_util.client import Client as EndpointUtilClient
|
|
10
|
+
from alibabacloud_ecd20201002 import models as ecd_20201002_models
|
|
11
|
+
from alibabacloud_tea_util import models as util_models
|
|
12
|
+
from alibabacloud_openapi_util.client import Client as OpenApiUtilClient
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
class Client(OpenApiClient):
|
|
16
|
+
"""
|
|
17
|
+
*\
|
|
18
|
+
"""
|
|
19
|
+
def __init__(
|
|
20
|
+
self,
|
|
21
|
+
config: open_api_models.Config,
|
|
22
|
+
):
|
|
23
|
+
super().__init__(config)
|
|
24
|
+
self._signature_algorithm = 'v2'
|
|
25
|
+
self._endpoint_rule = 'regional'
|
|
26
|
+
self.check_config(config)
|
|
27
|
+
self._endpoint = self.get_endpoint('ecd', self._region_id, self._endpoint_rule, self._network, self._suffix, self._endpoint_map, self._endpoint)
|
|
28
|
+
|
|
29
|
+
def get_endpoint(
|
|
30
|
+
self,
|
|
31
|
+
product_id: str,
|
|
32
|
+
region_id: str,
|
|
33
|
+
endpoint_rule: str,
|
|
34
|
+
network: str,
|
|
35
|
+
suffix: str,
|
|
36
|
+
endpoint_map: Dict[str, str],
|
|
37
|
+
endpoint: str,
|
|
38
|
+
) -> str:
|
|
39
|
+
if not UtilClient.empty(endpoint):
|
|
40
|
+
return endpoint
|
|
41
|
+
if not UtilClient.is_unset(endpoint_map) and not UtilClient.empty(endpoint_map.get(region_id)):
|
|
42
|
+
return endpoint_map.get(region_id)
|
|
43
|
+
return EndpointUtilClient.get_endpoint_rules(product_id, region_id, endpoint_rule, network, suffix)
|
|
44
|
+
|
|
45
|
+
def approve_fota_update_with_options(
|
|
46
|
+
self,
|
|
47
|
+
request: ecd_20201002_models.ApproveFotaUpdateRequest,
|
|
48
|
+
runtime: util_models.RuntimeOptions,
|
|
49
|
+
) -> ecd_20201002_models.ApproveFotaUpdateResponse:
|
|
50
|
+
UtilClient.validate_model(request)
|
|
51
|
+
query = {}
|
|
52
|
+
if not UtilClient.is_unset(request.app_version):
|
|
53
|
+
query['AppVersion'] = request.app_version
|
|
54
|
+
if not UtilClient.is_unset(request.client_id):
|
|
55
|
+
query['ClientId'] = request.client_id
|
|
56
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
57
|
+
query['DesktopId'] = request.desktop_id
|
|
58
|
+
if not UtilClient.is_unset(request.login_token):
|
|
59
|
+
query['LoginToken'] = request.login_token
|
|
60
|
+
if not UtilClient.is_unset(request.region_id):
|
|
61
|
+
query['RegionId'] = request.region_id
|
|
62
|
+
if not UtilClient.is_unset(request.session_id):
|
|
63
|
+
query['SessionId'] = request.session_id
|
|
64
|
+
if not UtilClient.is_unset(request.uuid):
|
|
65
|
+
query['Uuid'] = request.uuid
|
|
66
|
+
req = open_api_models.OpenApiRequest(
|
|
67
|
+
query=OpenApiUtilClient.query(query)
|
|
68
|
+
)
|
|
69
|
+
params = open_api_models.Params(
|
|
70
|
+
action='ApproveFotaUpdate',
|
|
71
|
+
version='2020-10-02',
|
|
72
|
+
protocol='HTTPS',
|
|
73
|
+
pathname='/',
|
|
74
|
+
method='POST',
|
|
75
|
+
auth_type='Anonymous',
|
|
76
|
+
style='RPC',
|
|
77
|
+
req_body_type='formData',
|
|
78
|
+
body_type='json'
|
|
79
|
+
)
|
|
80
|
+
return TeaCore.from_map(
|
|
81
|
+
ecd_20201002_models.ApproveFotaUpdateResponse(),
|
|
82
|
+
self.call_api(params, req, runtime)
|
|
83
|
+
)
|
|
84
|
+
|
|
85
|
+
async def approve_fota_update_with_options_async(
|
|
86
|
+
self,
|
|
87
|
+
request: ecd_20201002_models.ApproveFotaUpdateRequest,
|
|
88
|
+
runtime: util_models.RuntimeOptions,
|
|
89
|
+
) -> ecd_20201002_models.ApproveFotaUpdateResponse:
|
|
90
|
+
UtilClient.validate_model(request)
|
|
91
|
+
query = {}
|
|
92
|
+
if not UtilClient.is_unset(request.app_version):
|
|
93
|
+
query['AppVersion'] = request.app_version
|
|
94
|
+
if not UtilClient.is_unset(request.client_id):
|
|
95
|
+
query['ClientId'] = request.client_id
|
|
96
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
97
|
+
query['DesktopId'] = request.desktop_id
|
|
98
|
+
if not UtilClient.is_unset(request.login_token):
|
|
99
|
+
query['LoginToken'] = request.login_token
|
|
100
|
+
if not UtilClient.is_unset(request.region_id):
|
|
101
|
+
query['RegionId'] = request.region_id
|
|
102
|
+
if not UtilClient.is_unset(request.session_id):
|
|
103
|
+
query['SessionId'] = request.session_id
|
|
104
|
+
if not UtilClient.is_unset(request.uuid):
|
|
105
|
+
query['Uuid'] = request.uuid
|
|
106
|
+
req = open_api_models.OpenApiRequest(
|
|
107
|
+
query=OpenApiUtilClient.query(query)
|
|
108
|
+
)
|
|
109
|
+
params = open_api_models.Params(
|
|
110
|
+
action='ApproveFotaUpdate',
|
|
111
|
+
version='2020-10-02',
|
|
112
|
+
protocol='HTTPS',
|
|
113
|
+
pathname='/',
|
|
114
|
+
method='POST',
|
|
115
|
+
auth_type='Anonymous',
|
|
116
|
+
style='RPC',
|
|
117
|
+
req_body_type='formData',
|
|
118
|
+
body_type='json'
|
|
119
|
+
)
|
|
120
|
+
return TeaCore.from_map(
|
|
121
|
+
ecd_20201002_models.ApproveFotaUpdateResponse(),
|
|
122
|
+
await self.call_api_async(params, req, runtime)
|
|
123
|
+
)
|
|
124
|
+
|
|
125
|
+
def approve_fota_update(
|
|
126
|
+
self,
|
|
127
|
+
request: ecd_20201002_models.ApproveFotaUpdateRequest,
|
|
128
|
+
) -> ecd_20201002_models.ApproveFotaUpdateResponse:
|
|
129
|
+
runtime = util_models.RuntimeOptions()
|
|
130
|
+
return self.approve_fota_update_with_options(request, runtime)
|
|
131
|
+
|
|
132
|
+
async def approve_fota_update_async(
|
|
133
|
+
self,
|
|
134
|
+
request: ecd_20201002_models.ApproveFotaUpdateRequest,
|
|
135
|
+
) -> ecd_20201002_models.ApproveFotaUpdateResponse:
|
|
136
|
+
runtime = util_models.RuntimeOptions()
|
|
137
|
+
return await self.approve_fota_update_with_options_async(request, runtime)
|
|
138
|
+
|
|
139
|
+
def change_password_with_options(
|
|
140
|
+
self,
|
|
141
|
+
request: ecd_20201002_models.ChangePasswordRequest,
|
|
142
|
+
runtime: util_models.RuntimeOptions,
|
|
143
|
+
) -> ecd_20201002_models.ChangePasswordResponse:
|
|
144
|
+
UtilClient.validate_model(request)
|
|
145
|
+
query = {}
|
|
146
|
+
if not UtilClient.is_unset(request.client_id):
|
|
147
|
+
query['ClientId'] = request.client_id
|
|
148
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
149
|
+
query['EndUserId'] = request.end_user_id
|
|
150
|
+
if not UtilClient.is_unset(request.login_token):
|
|
151
|
+
query['LoginToken'] = request.login_token
|
|
152
|
+
if not UtilClient.is_unset(request.new_password):
|
|
153
|
+
query['NewPassword'] = request.new_password
|
|
154
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
155
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
156
|
+
if not UtilClient.is_unset(request.old_password):
|
|
157
|
+
query['OldPassword'] = request.old_password
|
|
158
|
+
if not UtilClient.is_unset(request.region_id):
|
|
159
|
+
query['RegionId'] = request.region_id
|
|
160
|
+
if not UtilClient.is_unset(request.session_id):
|
|
161
|
+
query['SessionId'] = request.session_id
|
|
162
|
+
req = open_api_models.OpenApiRequest(
|
|
163
|
+
query=OpenApiUtilClient.query(query)
|
|
164
|
+
)
|
|
165
|
+
params = open_api_models.Params(
|
|
166
|
+
action='ChangePassword',
|
|
167
|
+
version='2020-10-02',
|
|
168
|
+
protocol='HTTPS',
|
|
169
|
+
pathname='/',
|
|
170
|
+
method='POST',
|
|
171
|
+
auth_type='Anonymous',
|
|
172
|
+
style='RPC',
|
|
173
|
+
req_body_type='formData',
|
|
174
|
+
body_type='json'
|
|
175
|
+
)
|
|
176
|
+
return TeaCore.from_map(
|
|
177
|
+
ecd_20201002_models.ChangePasswordResponse(),
|
|
178
|
+
self.call_api(params, req, runtime)
|
|
179
|
+
)
|
|
180
|
+
|
|
181
|
+
async def change_password_with_options_async(
|
|
182
|
+
self,
|
|
183
|
+
request: ecd_20201002_models.ChangePasswordRequest,
|
|
184
|
+
runtime: util_models.RuntimeOptions,
|
|
185
|
+
) -> ecd_20201002_models.ChangePasswordResponse:
|
|
186
|
+
UtilClient.validate_model(request)
|
|
187
|
+
query = {}
|
|
188
|
+
if not UtilClient.is_unset(request.client_id):
|
|
189
|
+
query['ClientId'] = request.client_id
|
|
190
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
191
|
+
query['EndUserId'] = request.end_user_id
|
|
192
|
+
if not UtilClient.is_unset(request.login_token):
|
|
193
|
+
query['LoginToken'] = request.login_token
|
|
194
|
+
if not UtilClient.is_unset(request.new_password):
|
|
195
|
+
query['NewPassword'] = request.new_password
|
|
196
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
197
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
198
|
+
if not UtilClient.is_unset(request.old_password):
|
|
199
|
+
query['OldPassword'] = request.old_password
|
|
200
|
+
if not UtilClient.is_unset(request.region_id):
|
|
201
|
+
query['RegionId'] = request.region_id
|
|
202
|
+
if not UtilClient.is_unset(request.session_id):
|
|
203
|
+
query['SessionId'] = request.session_id
|
|
204
|
+
req = open_api_models.OpenApiRequest(
|
|
205
|
+
query=OpenApiUtilClient.query(query)
|
|
206
|
+
)
|
|
207
|
+
params = open_api_models.Params(
|
|
208
|
+
action='ChangePassword',
|
|
209
|
+
version='2020-10-02',
|
|
210
|
+
protocol='HTTPS',
|
|
211
|
+
pathname='/',
|
|
212
|
+
method='POST',
|
|
213
|
+
auth_type='Anonymous',
|
|
214
|
+
style='RPC',
|
|
215
|
+
req_body_type='formData',
|
|
216
|
+
body_type='json'
|
|
217
|
+
)
|
|
218
|
+
return TeaCore.from_map(
|
|
219
|
+
ecd_20201002_models.ChangePasswordResponse(),
|
|
220
|
+
await self.call_api_async(params, req, runtime)
|
|
221
|
+
)
|
|
222
|
+
|
|
223
|
+
def change_password(
|
|
224
|
+
self,
|
|
225
|
+
request: ecd_20201002_models.ChangePasswordRequest,
|
|
226
|
+
) -> ecd_20201002_models.ChangePasswordResponse:
|
|
227
|
+
runtime = util_models.RuntimeOptions()
|
|
228
|
+
return self.change_password_with_options(request, runtime)
|
|
229
|
+
|
|
230
|
+
async def change_password_async(
|
|
231
|
+
self,
|
|
232
|
+
request: ecd_20201002_models.ChangePasswordRequest,
|
|
233
|
+
) -> ecd_20201002_models.ChangePasswordResponse:
|
|
234
|
+
runtime = util_models.RuntimeOptions()
|
|
235
|
+
return await self.change_password_with_options_async(request, runtime)
|
|
236
|
+
|
|
237
|
+
def delete_finger_print_template_with_options(
|
|
238
|
+
self,
|
|
239
|
+
request: ecd_20201002_models.DeleteFingerPrintTemplateRequest,
|
|
240
|
+
runtime: util_models.RuntimeOptions,
|
|
241
|
+
) -> ecd_20201002_models.DeleteFingerPrintTemplateResponse:
|
|
242
|
+
UtilClient.validate_model(request)
|
|
243
|
+
query = {}
|
|
244
|
+
if not UtilClient.is_unset(request.client_id):
|
|
245
|
+
query['ClientId'] = request.client_id
|
|
246
|
+
if not UtilClient.is_unset(request.client_token):
|
|
247
|
+
query['ClientToken'] = request.client_token
|
|
248
|
+
if not UtilClient.is_unset(request.index):
|
|
249
|
+
query['Index'] = request.index
|
|
250
|
+
if not UtilClient.is_unset(request.login_token):
|
|
251
|
+
query['LoginToken'] = request.login_token
|
|
252
|
+
if not UtilClient.is_unset(request.region_id):
|
|
253
|
+
query['RegionId'] = request.region_id
|
|
254
|
+
if not UtilClient.is_unset(request.session_id):
|
|
255
|
+
query['SessionId'] = request.session_id
|
|
256
|
+
req = open_api_models.OpenApiRequest(
|
|
257
|
+
query=OpenApiUtilClient.query(query)
|
|
258
|
+
)
|
|
259
|
+
params = open_api_models.Params(
|
|
260
|
+
action='DeleteFingerPrintTemplate',
|
|
261
|
+
version='2020-10-02',
|
|
262
|
+
protocol='HTTPS',
|
|
263
|
+
pathname='/',
|
|
264
|
+
method='POST',
|
|
265
|
+
auth_type='Anonymous',
|
|
266
|
+
style='RPC',
|
|
267
|
+
req_body_type='formData',
|
|
268
|
+
body_type='json'
|
|
269
|
+
)
|
|
270
|
+
return TeaCore.from_map(
|
|
271
|
+
ecd_20201002_models.DeleteFingerPrintTemplateResponse(),
|
|
272
|
+
self.call_api(params, req, runtime)
|
|
273
|
+
)
|
|
274
|
+
|
|
275
|
+
async def delete_finger_print_template_with_options_async(
|
|
276
|
+
self,
|
|
277
|
+
request: ecd_20201002_models.DeleteFingerPrintTemplateRequest,
|
|
278
|
+
runtime: util_models.RuntimeOptions,
|
|
279
|
+
) -> ecd_20201002_models.DeleteFingerPrintTemplateResponse:
|
|
280
|
+
UtilClient.validate_model(request)
|
|
281
|
+
query = {}
|
|
282
|
+
if not UtilClient.is_unset(request.client_id):
|
|
283
|
+
query['ClientId'] = request.client_id
|
|
284
|
+
if not UtilClient.is_unset(request.client_token):
|
|
285
|
+
query['ClientToken'] = request.client_token
|
|
286
|
+
if not UtilClient.is_unset(request.index):
|
|
287
|
+
query['Index'] = request.index
|
|
288
|
+
if not UtilClient.is_unset(request.login_token):
|
|
289
|
+
query['LoginToken'] = request.login_token
|
|
290
|
+
if not UtilClient.is_unset(request.region_id):
|
|
291
|
+
query['RegionId'] = request.region_id
|
|
292
|
+
if not UtilClient.is_unset(request.session_id):
|
|
293
|
+
query['SessionId'] = request.session_id
|
|
294
|
+
req = open_api_models.OpenApiRequest(
|
|
295
|
+
query=OpenApiUtilClient.query(query)
|
|
296
|
+
)
|
|
297
|
+
params = open_api_models.Params(
|
|
298
|
+
action='DeleteFingerPrintTemplate',
|
|
299
|
+
version='2020-10-02',
|
|
300
|
+
protocol='HTTPS',
|
|
301
|
+
pathname='/',
|
|
302
|
+
method='POST',
|
|
303
|
+
auth_type='Anonymous',
|
|
304
|
+
style='RPC',
|
|
305
|
+
req_body_type='formData',
|
|
306
|
+
body_type='json'
|
|
307
|
+
)
|
|
308
|
+
return TeaCore.from_map(
|
|
309
|
+
ecd_20201002_models.DeleteFingerPrintTemplateResponse(),
|
|
310
|
+
await self.call_api_async(params, req, runtime)
|
|
311
|
+
)
|
|
312
|
+
|
|
313
|
+
def delete_finger_print_template(
|
|
314
|
+
self,
|
|
315
|
+
request: ecd_20201002_models.DeleteFingerPrintTemplateRequest,
|
|
316
|
+
) -> ecd_20201002_models.DeleteFingerPrintTemplateResponse:
|
|
317
|
+
runtime = util_models.RuntimeOptions()
|
|
318
|
+
return self.delete_finger_print_template_with_options(request, runtime)
|
|
319
|
+
|
|
320
|
+
async def delete_finger_print_template_async(
|
|
321
|
+
self,
|
|
322
|
+
request: ecd_20201002_models.DeleteFingerPrintTemplateRequest,
|
|
323
|
+
) -> ecd_20201002_models.DeleteFingerPrintTemplateResponse:
|
|
324
|
+
runtime = util_models.RuntimeOptions()
|
|
325
|
+
return await self.delete_finger_print_template_with_options_async(request, runtime)
|
|
326
|
+
|
|
327
|
+
def describe_directories_with_options(
|
|
328
|
+
self,
|
|
329
|
+
request: ecd_20201002_models.DescribeDirectoriesRequest,
|
|
330
|
+
runtime: util_models.RuntimeOptions,
|
|
331
|
+
) -> ecd_20201002_models.DescribeDirectoriesResponse:
|
|
332
|
+
UtilClient.validate_model(request)
|
|
333
|
+
query = {}
|
|
334
|
+
if not UtilClient.is_unset(request.client_id):
|
|
335
|
+
query['ClientId'] = request.client_id
|
|
336
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
337
|
+
query['DirectoryId'] = request.directory_id
|
|
338
|
+
if not UtilClient.is_unset(request.region_id):
|
|
339
|
+
query['RegionId'] = request.region_id
|
|
340
|
+
req = open_api_models.OpenApiRequest(
|
|
341
|
+
query=OpenApiUtilClient.query(query)
|
|
342
|
+
)
|
|
343
|
+
params = open_api_models.Params(
|
|
344
|
+
action='DescribeDirectories',
|
|
345
|
+
version='2020-10-02',
|
|
346
|
+
protocol='HTTPS',
|
|
347
|
+
pathname='/',
|
|
348
|
+
method='POST',
|
|
349
|
+
auth_type='Anonymous',
|
|
350
|
+
style='RPC',
|
|
351
|
+
req_body_type='formData',
|
|
352
|
+
body_type='json'
|
|
353
|
+
)
|
|
354
|
+
return TeaCore.from_map(
|
|
355
|
+
ecd_20201002_models.DescribeDirectoriesResponse(),
|
|
356
|
+
self.call_api(params, req, runtime)
|
|
357
|
+
)
|
|
358
|
+
|
|
359
|
+
async def describe_directories_with_options_async(
|
|
360
|
+
self,
|
|
361
|
+
request: ecd_20201002_models.DescribeDirectoriesRequest,
|
|
362
|
+
runtime: util_models.RuntimeOptions,
|
|
363
|
+
) -> ecd_20201002_models.DescribeDirectoriesResponse:
|
|
364
|
+
UtilClient.validate_model(request)
|
|
365
|
+
query = {}
|
|
366
|
+
if not UtilClient.is_unset(request.client_id):
|
|
367
|
+
query['ClientId'] = request.client_id
|
|
368
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
369
|
+
query['DirectoryId'] = request.directory_id
|
|
370
|
+
if not UtilClient.is_unset(request.region_id):
|
|
371
|
+
query['RegionId'] = request.region_id
|
|
372
|
+
req = open_api_models.OpenApiRequest(
|
|
373
|
+
query=OpenApiUtilClient.query(query)
|
|
374
|
+
)
|
|
375
|
+
params = open_api_models.Params(
|
|
376
|
+
action='DescribeDirectories',
|
|
377
|
+
version='2020-10-02',
|
|
378
|
+
protocol='HTTPS',
|
|
379
|
+
pathname='/',
|
|
380
|
+
method='POST',
|
|
381
|
+
auth_type='Anonymous',
|
|
382
|
+
style='RPC',
|
|
383
|
+
req_body_type='formData',
|
|
384
|
+
body_type='json'
|
|
385
|
+
)
|
|
386
|
+
return TeaCore.from_map(
|
|
387
|
+
ecd_20201002_models.DescribeDirectoriesResponse(),
|
|
388
|
+
await self.call_api_async(params, req, runtime)
|
|
389
|
+
)
|
|
390
|
+
|
|
391
|
+
def describe_directories(
|
|
392
|
+
self,
|
|
393
|
+
request: ecd_20201002_models.DescribeDirectoriesRequest,
|
|
394
|
+
) -> ecd_20201002_models.DescribeDirectoriesResponse:
|
|
395
|
+
runtime = util_models.RuntimeOptions()
|
|
396
|
+
return self.describe_directories_with_options(request, runtime)
|
|
397
|
+
|
|
398
|
+
async def describe_directories_async(
|
|
399
|
+
self,
|
|
400
|
+
request: ecd_20201002_models.DescribeDirectoriesRequest,
|
|
401
|
+
) -> ecd_20201002_models.DescribeDirectoriesResponse:
|
|
402
|
+
runtime = util_models.RuntimeOptions()
|
|
403
|
+
return await self.describe_directories_with_options_async(request, runtime)
|
|
404
|
+
|
|
405
|
+
def describe_finger_print_templates_with_options(
|
|
406
|
+
self,
|
|
407
|
+
request: ecd_20201002_models.DescribeFingerPrintTemplatesRequest,
|
|
408
|
+
runtime: util_models.RuntimeOptions,
|
|
409
|
+
) -> ecd_20201002_models.DescribeFingerPrintTemplatesResponse:
|
|
410
|
+
UtilClient.validate_model(request)
|
|
411
|
+
query = {}
|
|
412
|
+
if not UtilClient.is_unset(request.client_id):
|
|
413
|
+
query['ClientId'] = request.client_id
|
|
414
|
+
if not UtilClient.is_unset(request.login_token):
|
|
415
|
+
query['LoginToken'] = request.login_token
|
|
416
|
+
if not UtilClient.is_unset(request.region_id):
|
|
417
|
+
query['RegionId'] = request.region_id
|
|
418
|
+
if not UtilClient.is_unset(request.session_id):
|
|
419
|
+
query['SessionId'] = request.session_id
|
|
420
|
+
req = open_api_models.OpenApiRequest(
|
|
421
|
+
query=OpenApiUtilClient.query(query)
|
|
422
|
+
)
|
|
423
|
+
params = open_api_models.Params(
|
|
424
|
+
action='DescribeFingerPrintTemplates',
|
|
425
|
+
version='2020-10-02',
|
|
426
|
+
protocol='HTTPS',
|
|
427
|
+
pathname='/',
|
|
428
|
+
method='POST',
|
|
429
|
+
auth_type='Anonymous',
|
|
430
|
+
style='RPC',
|
|
431
|
+
req_body_type='formData',
|
|
432
|
+
body_type='json'
|
|
433
|
+
)
|
|
434
|
+
return TeaCore.from_map(
|
|
435
|
+
ecd_20201002_models.DescribeFingerPrintTemplatesResponse(),
|
|
436
|
+
self.call_api(params, req, runtime)
|
|
437
|
+
)
|
|
438
|
+
|
|
439
|
+
async def describe_finger_print_templates_with_options_async(
|
|
440
|
+
self,
|
|
441
|
+
request: ecd_20201002_models.DescribeFingerPrintTemplatesRequest,
|
|
442
|
+
runtime: util_models.RuntimeOptions,
|
|
443
|
+
) -> ecd_20201002_models.DescribeFingerPrintTemplatesResponse:
|
|
444
|
+
UtilClient.validate_model(request)
|
|
445
|
+
query = {}
|
|
446
|
+
if not UtilClient.is_unset(request.client_id):
|
|
447
|
+
query['ClientId'] = request.client_id
|
|
448
|
+
if not UtilClient.is_unset(request.login_token):
|
|
449
|
+
query['LoginToken'] = request.login_token
|
|
450
|
+
if not UtilClient.is_unset(request.region_id):
|
|
451
|
+
query['RegionId'] = request.region_id
|
|
452
|
+
if not UtilClient.is_unset(request.session_id):
|
|
453
|
+
query['SessionId'] = request.session_id
|
|
454
|
+
req = open_api_models.OpenApiRequest(
|
|
455
|
+
query=OpenApiUtilClient.query(query)
|
|
456
|
+
)
|
|
457
|
+
params = open_api_models.Params(
|
|
458
|
+
action='DescribeFingerPrintTemplates',
|
|
459
|
+
version='2020-10-02',
|
|
460
|
+
protocol='HTTPS',
|
|
461
|
+
pathname='/',
|
|
462
|
+
method='POST',
|
|
463
|
+
auth_type='Anonymous',
|
|
464
|
+
style='RPC',
|
|
465
|
+
req_body_type='formData',
|
|
466
|
+
body_type='json'
|
|
467
|
+
)
|
|
468
|
+
return TeaCore.from_map(
|
|
469
|
+
ecd_20201002_models.DescribeFingerPrintTemplatesResponse(),
|
|
470
|
+
await self.call_api_async(params, req, runtime)
|
|
471
|
+
)
|
|
472
|
+
|
|
473
|
+
def describe_finger_print_templates(
|
|
474
|
+
self,
|
|
475
|
+
request: ecd_20201002_models.DescribeFingerPrintTemplatesRequest,
|
|
476
|
+
) -> ecd_20201002_models.DescribeFingerPrintTemplatesResponse:
|
|
477
|
+
runtime = util_models.RuntimeOptions()
|
|
478
|
+
return self.describe_finger_print_templates_with_options(request, runtime)
|
|
479
|
+
|
|
480
|
+
async def describe_finger_print_templates_async(
|
|
481
|
+
self,
|
|
482
|
+
request: ecd_20201002_models.DescribeFingerPrintTemplatesRequest,
|
|
483
|
+
) -> ecd_20201002_models.DescribeFingerPrintTemplatesResponse:
|
|
484
|
+
runtime = util_models.RuntimeOptions()
|
|
485
|
+
return await self.describe_finger_print_templates_with_options_async(request, runtime)
|
|
486
|
+
|
|
487
|
+
def describe_global_desktops_with_options(
|
|
488
|
+
self,
|
|
489
|
+
request: ecd_20201002_models.DescribeGlobalDesktopsRequest,
|
|
490
|
+
runtime: util_models.RuntimeOptions,
|
|
491
|
+
) -> ecd_20201002_models.DescribeGlobalDesktopsResponse:
|
|
492
|
+
UtilClient.validate_model(request)
|
|
493
|
+
query = {}
|
|
494
|
+
if not UtilClient.is_unset(request.client_id):
|
|
495
|
+
query['ClientId'] = request.client_id
|
|
496
|
+
if not UtilClient.is_unset(request.desktop_access_type):
|
|
497
|
+
query['DesktopAccessType'] = request.desktop_access_type
|
|
498
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
499
|
+
query['DesktopId'] = request.desktop_id
|
|
500
|
+
if not UtilClient.is_unset(request.desktop_name):
|
|
501
|
+
query['DesktopName'] = request.desktop_name
|
|
502
|
+
if not UtilClient.is_unset(request.desktop_status):
|
|
503
|
+
query['DesktopStatus'] = request.desktop_status
|
|
504
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
505
|
+
query['DirectoryId'] = request.directory_id
|
|
506
|
+
if not UtilClient.is_unset(request.keyword):
|
|
507
|
+
query['Keyword'] = request.keyword
|
|
508
|
+
if not UtilClient.is_unset(request.login_region_id):
|
|
509
|
+
query['LoginRegionId'] = request.login_region_id
|
|
510
|
+
if not UtilClient.is_unset(request.login_token):
|
|
511
|
+
query['LoginToken'] = request.login_token
|
|
512
|
+
if not UtilClient.is_unset(request.max_results):
|
|
513
|
+
query['MaxResults'] = request.max_results
|
|
514
|
+
if not UtilClient.is_unset(request.next_token):
|
|
515
|
+
query['NextToken'] = request.next_token
|
|
516
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
517
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
518
|
+
if not UtilClient.is_unset(request.order_by):
|
|
519
|
+
query['OrderBy'] = request.order_by
|
|
520
|
+
if not UtilClient.is_unset(request.query_fota_update):
|
|
521
|
+
query['QueryFotaUpdate'] = request.query_fota_update
|
|
522
|
+
if not UtilClient.is_unset(request.region_id):
|
|
523
|
+
query['RegionId'] = request.region_id
|
|
524
|
+
if not UtilClient.is_unset(request.search_region_id):
|
|
525
|
+
query['SearchRegionId'] = request.search_region_id
|
|
526
|
+
if not UtilClient.is_unset(request.session_id):
|
|
527
|
+
query['SessionId'] = request.session_id
|
|
528
|
+
if not UtilClient.is_unset(request.sort_type):
|
|
529
|
+
query['SortType'] = request.sort_type
|
|
530
|
+
if not UtilClient.is_unset(request.without_latency):
|
|
531
|
+
query['WithoutLatency'] = request.without_latency
|
|
532
|
+
req = open_api_models.OpenApiRequest(
|
|
533
|
+
query=OpenApiUtilClient.query(query)
|
|
534
|
+
)
|
|
535
|
+
params = open_api_models.Params(
|
|
536
|
+
action='DescribeGlobalDesktops',
|
|
537
|
+
version='2020-10-02',
|
|
538
|
+
protocol='HTTPS',
|
|
539
|
+
pathname='/',
|
|
540
|
+
method='POST',
|
|
541
|
+
auth_type='Anonymous',
|
|
542
|
+
style='RPC',
|
|
543
|
+
req_body_type='formData',
|
|
544
|
+
body_type='json'
|
|
545
|
+
)
|
|
546
|
+
return TeaCore.from_map(
|
|
547
|
+
ecd_20201002_models.DescribeGlobalDesktopsResponse(),
|
|
548
|
+
self.call_api(params, req, runtime)
|
|
549
|
+
)
|
|
550
|
+
|
|
551
|
+
async def describe_global_desktops_with_options_async(
|
|
552
|
+
self,
|
|
553
|
+
request: ecd_20201002_models.DescribeGlobalDesktopsRequest,
|
|
554
|
+
runtime: util_models.RuntimeOptions,
|
|
555
|
+
) -> ecd_20201002_models.DescribeGlobalDesktopsResponse:
|
|
556
|
+
UtilClient.validate_model(request)
|
|
557
|
+
query = {}
|
|
558
|
+
if not UtilClient.is_unset(request.client_id):
|
|
559
|
+
query['ClientId'] = request.client_id
|
|
560
|
+
if not UtilClient.is_unset(request.desktop_access_type):
|
|
561
|
+
query['DesktopAccessType'] = request.desktop_access_type
|
|
562
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
563
|
+
query['DesktopId'] = request.desktop_id
|
|
564
|
+
if not UtilClient.is_unset(request.desktop_name):
|
|
565
|
+
query['DesktopName'] = request.desktop_name
|
|
566
|
+
if not UtilClient.is_unset(request.desktop_status):
|
|
567
|
+
query['DesktopStatus'] = request.desktop_status
|
|
568
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
569
|
+
query['DirectoryId'] = request.directory_id
|
|
570
|
+
if not UtilClient.is_unset(request.keyword):
|
|
571
|
+
query['Keyword'] = request.keyword
|
|
572
|
+
if not UtilClient.is_unset(request.login_region_id):
|
|
573
|
+
query['LoginRegionId'] = request.login_region_id
|
|
574
|
+
if not UtilClient.is_unset(request.login_token):
|
|
575
|
+
query['LoginToken'] = request.login_token
|
|
576
|
+
if not UtilClient.is_unset(request.max_results):
|
|
577
|
+
query['MaxResults'] = request.max_results
|
|
578
|
+
if not UtilClient.is_unset(request.next_token):
|
|
579
|
+
query['NextToken'] = request.next_token
|
|
580
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
581
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
582
|
+
if not UtilClient.is_unset(request.order_by):
|
|
583
|
+
query['OrderBy'] = request.order_by
|
|
584
|
+
if not UtilClient.is_unset(request.query_fota_update):
|
|
585
|
+
query['QueryFotaUpdate'] = request.query_fota_update
|
|
586
|
+
if not UtilClient.is_unset(request.region_id):
|
|
587
|
+
query['RegionId'] = request.region_id
|
|
588
|
+
if not UtilClient.is_unset(request.search_region_id):
|
|
589
|
+
query['SearchRegionId'] = request.search_region_id
|
|
590
|
+
if not UtilClient.is_unset(request.session_id):
|
|
591
|
+
query['SessionId'] = request.session_id
|
|
592
|
+
if not UtilClient.is_unset(request.sort_type):
|
|
593
|
+
query['SortType'] = request.sort_type
|
|
594
|
+
if not UtilClient.is_unset(request.without_latency):
|
|
595
|
+
query['WithoutLatency'] = request.without_latency
|
|
596
|
+
req = open_api_models.OpenApiRequest(
|
|
597
|
+
query=OpenApiUtilClient.query(query)
|
|
598
|
+
)
|
|
599
|
+
params = open_api_models.Params(
|
|
600
|
+
action='DescribeGlobalDesktops',
|
|
601
|
+
version='2020-10-02',
|
|
602
|
+
protocol='HTTPS',
|
|
603
|
+
pathname='/',
|
|
604
|
+
method='POST',
|
|
605
|
+
auth_type='Anonymous',
|
|
606
|
+
style='RPC',
|
|
607
|
+
req_body_type='formData',
|
|
608
|
+
body_type='json'
|
|
609
|
+
)
|
|
610
|
+
return TeaCore.from_map(
|
|
611
|
+
ecd_20201002_models.DescribeGlobalDesktopsResponse(),
|
|
612
|
+
await self.call_api_async(params, req, runtime)
|
|
613
|
+
)
|
|
614
|
+
|
|
615
|
+
def describe_global_desktops(
|
|
616
|
+
self,
|
|
617
|
+
request: ecd_20201002_models.DescribeGlobalDesktopsRequest,
|
|
618
|
+
) -> ecd_20201002_models.DescribeGlobalDesktopsResponse:
|
|
619
|
+
runtime = util_models.RuntimeOptions()
|
|
620
|
+
return self.describe_global_desktops_with_options(request, runtime)
|
|
621
|
+
|
|
622
|
+
async def describe_global_desktops_async(
|
|
623
|
+
self,
|
|
624
|
+
request: ecd_20201002_models.DescribeGlobalDesktopsRequest,
|
|
625
|
+
) -> ecd_20201002_models.DescribeGlobalDesktopsResponse:
|
|
626
|
+
runtime = util_models.RuntimeOptions()
|
|
627
|
+
return await self.describe_global_desktops_with_options_async(request, runtime)
|
|
628
|
+
|
|
629
|
+
def describe_office_sites_with_options(
|
|
630
|
+
self,
|
|
631
|
+
request: ecd_20201002_models.DescribeOfficeSitesRequest,
|
|
632
|
+
runtime: util_models.RuntimeOptions,
|
|
633
|
+
) -> ecd_20201002_models.DescribeOfficeSitesResponse:
|
|
634
|
+
UtilClient.validate_model(request)
|
|
635
|
+
query = {}
|
|
636
|
+
if not UtilClient.is_unset(request.client_id):
|
|
637
|
+
query['ClientId'] = request.client_id
|
|
638
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
639
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
640
|
+
if not UtilClient.is_unset(request.region_id):
|
|
641
|
+
query['RegionId'] = request.region_id
|
|
642
|
+
req = open_api_models.OpenApiRequest(
|
|
643
|
+
query=OpenApiUtilClient.query(query)
|
|
644
|
+
)
|
|
645
|
+
params = open_api_models.Params(
|
|
646
|
+
action='DescribeOfficeSites',
|
|
647
|
+
version='2020-10-02',
|
|
648
|
+
protocol='HTTPS',
|
|
649
|
+
pathname='/',
|
|
650
|
+
method='POST',
|
|
651
|
+
auth_type='Anonymous',
|
|
652
|
+
style='RPC',
|
|
653
|
+
req_body_type='formData',
|
|
654
|
+
body_type='json'
|
|
655
|
+
)
|
|
656
|
+
return TeaCore.from_map(
|
|
657
|
+
ecd_20201002_models.DescribeOfficeSitesResponse(),
|
|
658
|
+
self.call_api(params, req, runtime)
|
|
659
|
+
)
|
|
660
|
+
|
|
661
|
+
async def describe_office_sites_with_options_async(
|
|
662
|
+
self,
|
|
663
|
+
request: ecd_20201002_models.DescribeOfficeSitesRequest,
|
|
664
|
+
runtime: util_models.RuntimeOptions,
|
|
665
|
+
) -> ecd_20201002_models.DescribeOfficeSitesResponse:
|
|
666
|
+
UtilClient.validate_model(request)
|
|
667
|
+
query = {}
|
|
668
|
+
if not UtilClient.is_unset(request.client_id):
|
|
669
|
+
query['ClientId'] = request.client_id
|
|
670
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
671
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
672
|
+
if not UtilClient.is_unset(request.region_id):
|
|
673
|
+
query['RegionId'] = request.region_id
|
|
674
|
+
req = open_api_models.OpenApiRequest(
|
|
675
|
+
query=OpenApiUtilClient.query(query)
|
|
676
|
+
)
|
|
677
|
+
params = open_api_models.Params(
|
|
678
|
+
action='DescribeOfficeSites',
|
|
679
|
+
version='2020-10-02',
|
|
680
|
+
protocol='HTTPS',
|
|
681
|
+
pathname='/',
|
|
682
|
+
method='POST',
|
|
683
|
+
auth_type='Anonymous',
|
|
684
|
+
style='RPC',
|
|
685
|
+
req_body_type='formData',
|
|
686
|
+
body_type='json'
|
|
687
|
+
)
|
|
688
|
+
return TeaCore.from_map(
|
|
689
|
+
ecd_20201002_models.DescribeOfficeSitesResponse(),
|
|
690
|
+
await self.call_api_async(params, req, runtime)
|
|
691
|
+
)
|
|
692
|
+
|
|
693
|
+
def describe_office_sites(
|
|
694
|
+
self,
|
|
695
|
+
request: ecd_20201002_models.DescribeOfficeSitesRequest,
|
|
696
|
+
) -> ecd_20201002_models.DescribeOfficeSitesResponse:
|
|
697
|
+
runtime = util_models.RuntimeOptions()
|
|
698
|
+
return self.describe_office_sites_with_options(request, runtime)
|
|
699
|
+
|
|
700
|
+
async def describe_office_sites_async(
|
|
701
|
+
self,
|
|
702
|
+
request: ecd_20201002_models.DescribeOfficeSitesRequest,
|
|
703
|
+
) -> ecd_20201002_models.DescribeOfficeSitesResponse:
|
|
704
|
+
runtime = util_models.RuntimeOptions()
|
|
705
|
+
return await self.describe_office_sites_with_options_async(request, runtime)
|
|
706
|
+
|
|
707
|
+
def describe_regions_with_options(
|
|
708
|
+
self,
|
|
709
|
+
request: ecd_20201002_models.DescribeRegionsRequest,
|
|
710
|
+
runtime: util_models.RuntimeOptions,
|
|
711
|
+
) -> ecd_20201002_models.DescribeRegionsResponse:
|
|
712
|
+
UtilClient.validate_model(request)
|
|
713
|
+
query = {}
|
|
714
|
+
if not UtilClient.is_unset(request.client_id):
|
|
715
|
+
query['ClientId'] = request.client_id
|
|
716
|
+
if not UtilClient.is_unset(request.region_id):
|
|
717
|
+
query['RegionId'] = request.region_id
|
|
718
|
+
req = open_api_models.OpenApiRequest(
|
|
719
|
+
query=OpenApiUtilClient.query(query)
|
|
720
|
+
)
|
|
721
|
+
params = open_api_models.Params(
|
|
722
|
+
action='DescribeRegions',
|
|
723
|
+
version='2020-10-02',
|
|
724
|
+
protocol='HTTPS',
|
|
725
|
+
pathname='/',
|
|
726
|
+
method='POST',
|
|
727
|
+
auth_type='Anonymous',
|
|
728
|
+
style='RPC',
|
|
729
|
+
req_body_type='formData',
|
|
730
|
+
body_type='json'
|
|
731
|
+
)
|
|
732
|
+
return TeaCore.from_map(
|
|
733
|
+
ecd_20201002_models.DescribeRegionsResponse(),
|
|
734
|
+
self.call_api(params, req, runtime)
|
|
735
|
+
)
|
|
736
|
+
|
|
737
|
+
async def describe_regions_with_options_async(
|
|
738
|
+
self,
|
|
739
|
+
request: ecd_20201002_models.DescribeRegionsRequest,
|
|
740
|
+
runtime: util_models.RuntimeOptions,
|
|
741
|
+
) -> ecd_20201002_models.DescribeRegionsResponse:
|
|
742
|
+
UtilClient.validate_model(request)
|
|
743
|
+
query = {}
|
|
744
|
+
if not UtilClient.is_unset(request.client_id):
|
|
745
|
+
query['ClientId'] = request.client_id
|
|
746
|
+
if not UtilClient.is_unset(request.region_id):
|
|
747
|
+
query['RegionId'] = request.region_id
|
|
748
|
+
req = open_api_models.OpenApiRequest(
|
|
749
|
+
query=OpenApiUtilClient.query(query)
|
|
750
|
+
)
|
|
751
|
+
params = open_api_models.Params(
|
|
752
|
+
action='DescribeRegions',
|
|
753
|
+
version='2020-10-02',
|
|
754
|
+
protocol='HTTPS',
|
|
755
|
+
pathname='/',
|
|
756
|
+
method='POST',
|
|
757
|
+
auth_type='Anonymous',
|
|
758
|
+
style='RPC',
|
|
759
|
+
req_body_type='formData',
|
|
760
|
+
body_type='json'
|
|
761
|
+
)
|
|
762
|
+
return TeaCore.from_map(
|
|
763
|
+
ecd_20201002_models.DescribeRegionsResponse(),
|
|
764
|
+
await self.call_api_async(params, req, runtime)
|
|
765
|
+
)
|
|
766
|
+
|
|
767
|
+
def describe_regions(
|
|
768
|
+
self,
|
|
769
|
+
request: ecd_20201002_models.DescribeRegionsRequest,
|
|
770
|
+
) -> ecd_20201002_models.DescribeRegionsResponse:
|
|
771
|
+
runtime = util_models.RuntimeOptions()
|
|
772
|
+
return self.describe_regions_with_options(request, runtime)
|
|
773
|
+
|
|
774
|
+
async def describe_regions_async(
|
|
775
|
+
self,
|
|
776
|
+
request: ecd_20201002_models.DescribeRegionsRequest,
|
|
777
|
+
) -> ecd_20201002_models.DescribeRegionsResponse:
|
|
778
|
+
runtime = util_models.RuntimeOptions()
|
|
779
|
+
return await self.describe_regions_with_options_async(request, runtime)
|
|
780
|
+
|
|
781
|
+
def describe_snapshots_with_options(
|
|
782
|
+
self,
|
|
783
|
+
request: ecd_20201002_models.DescribeSnapshotsRequest,
|
|
784
|
+
runtime: util_models.RuntimeOptions,
|
|
785
|
+
) -> ecd_20201002_models.DescribeSnapshotsResponse:
|
|
786
|
+
UtilClient.validate_model(request)
|
|
787
|
+
query = {}
|
|
788
|
+
if not UtilClient.is_unset(request.client_id):
|
|
789
|
+
query['ClientId'] = request.client_id
|
|
790
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
791
|
+
query['DesktopId'] = request.desktop_id
|
|
792
|
+
if not UtilClient.is_unset(request.login_token):
|
|
793
|
+
query['LoginToken'] = request.login_token
|
|
794
|
+
if not UtilClient.is_unset(request.max_results):
|
|
795
|
+
query['MaxResults'] = request.max_results
|
|
796
|
+
if not UtilClient.is_unset(request.next_token):
|
|
797
|
+
query['NextToken'] = request.next_token
|
|
798
|
+
if not UtilClient.is_unset(request.region_id):
|
|
799
|
+
query['RegionId'] = request.region_id
|
|
800
|
+
if not UtilClient.is_unset(request.session_id):
|
|
801
|
+
query['SessionId'] = request.session_id
|
|
802
|
+
if not UtilClient.is_unset(request.snapshot_id):
|
|
803
|
+
query['SnapshotId'] = request.snapshot_id
|
|
804
|
+
req = open_api_models.OpenApiRequest(
|
|
805
|
+
query=OpenApiUtilClient.query(query)
|
|
806
|
+
)
|
|
807
|
+
params = open_api_models.Params(
|
|
808
|
+
action='DescribeSnapshots',
|
|
809
|
+
version='2020-10-02',
|
|
810
|
+
protocol='HTTPS',
|
|
811
|
+
pathname='/',
|
|
812
|
+
method='POST',
|
|
813
|
+
auth_type='Anonymous',
|
|
814
|
+
style='RPC',
|
|
815
|
+
req_body_type='formData',
|
|
816
|
+
body_type='json'
|
|
817
|
+
)
|
|
818
|
+
return TeaCore.from_map(
|
|
819
|
+
ecd_20201002_models.DescribeSnapshotsResponse(),
|
|
820
|
+
self.call_api(params, req, runtime)
|
|
821
|
+
)
|
|
822
|
+
|
|
823
|
+
async def describe_snapshots_with_options_async(
|
|
824
|
+
self,
|
|
825
|
+
request: ecd_20201002_models.DescribeSnapshotsRequest,
|
|
826
|
+
runtime: util_models.RuntimeOptions,
|
|
827
|
+
) -> ecd_20201002_models.DescribeSnapshotsResponse:
|
|
828
|
+
UtilClient.validate_model(request)
|
|
829
|
+
query = {}
|
|
830
|
+
if not UtilClient.is_unset(request.client_id):
|
|
831
|
+
query['ClientId'] = request.client_id
|
|
832
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
833
|
+
query['DesktopId'] = request.desktop_id
|
|
834
|
+
if not UtilClient.is_unset(request.login_token):
|
|
835
|
+
query['LoginToken'] = request.login_token
|
|
836
|
+
if not UtilClient.is_unset(request.max_results):
|
|
837
|
+
query['MaxResults'] = request.max_results
|
|
838
|
+
if not UtilClient.is_unset(request.next_token):
|
|
839
|
+
query['NextToken'] = request.next_token
|
|
840
|
+
if not UtilClient.is_unset(request.region_id):
|
|
841
|
+
query['RegionId'] = request.region_id
|
|
842
|
+
if not UtilClient.is_unset(request.session_id):
|
|
843
|
+
query['SessionId'] = request.session_id
|
|
844
|
+
if not UtilClient.is_unset(request.snapshot_id):
|
|
845
|
+
query['SnapshotId'] = request.snapshot_id
|
|
846
|
+
req = open_api_models.OpenApiRequest(
|
|
847
|
+
query=OpenApiUtilClient.query(query)
|
|
848
|
+
)
|
|
849
|
+
params = open_api_models.Params(
|
|
850
|
+
action='DescribeSnapshots',
|
|
851
|
+
version='2020-10-02',
|
|
852
|
+
protocol='HTTPS',
|
|
853
|
+
pathname='/',
|
|
854
|
+
method='POST',
|
|
855
|
+
auth_type='Anonymous',
|
|
856
|
+
style='RPC',
|
|
857
|
+
req_body_type='formData',
|
|
858
|
+
body_type='json'
|
|
859
|
+
)
|
|
860
|
+
return TeaCore.from_map(
|
|
861
|
+
ecd_20201002_models.DescribeSnapshotsResponse(),
|
|
862
|
+
await self.call_api_async(params, req, runtime)
|
|
863
|
+
)
|
|
864
|
+
|
|
865
|
+
def describe_snapshots(
|
|
866
|
+
self,
|
|
867
|
+
request: ecd_20201002_models.DescribeSnapshotsRequest,
|
|
868
|
+
) -> ecd_20201002_models.DescribeSnapshotsResponse:
|
|
869
|
+
runtime = util_models.RuntimeOptions()
|
|
870
|
+
return self.describe_snapshots_with_options(request, runtime)
|
|
871
|
+
|
|
872
|
+
async def describe_snapshots_async(
|
|
873
|
+
self,
|
|
874
|
+
request: ecd_20201002_models.DescribeSnapshotsRequest,
|
|
875
|
+
) -> ecd_20201002_models.DescribeSnapshotsResponse:
|
|
876
|
+
runtime = util_models.RuntimeOptions()
|
|
877
|
+
return await self.describe_snapshots_with_options_async(request, runtime)
|
|
878
|
+
|
|
879
|
+
def encrypt_password_with_options(
|
|
880
|
+
self,
|
|
881
|
+
request: ecd_20201002_models.EncryptPasswordRequest,
|
|
882
|
+
runtime: util_models.RuntimeOptions,
|
|
883
|
+
) -> ecd_20201002_models.EncryptPasswordResponse:
|
|
884
|
+
UtilClient.validate_model(request)
|
|
885
|
+
query = {}
|
|
886
|
+
if not UtilClient.is_unset(request.client_id):
|
|
887
|
+
query['ClientId'] = request.client_id
|
|
888
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
889
|
+
query['DirectoryId'] = request.directory_id
|
|
890
|
+
if not UtilClient.is_unset(request.login_token):
|
|
891
|
+
query['LoginToken'] = request.login_token
|
|
892
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
893
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
894
|
+
if not UtilClient.is_unset(request.password):
|
|
895
|
+
query['Password'] = request.password
|
|
896
|
+
if not UtilClient.is_unset(request.region_id):
|
|
897
|
+
query['RegionId'] = request.region_id
|
|
898
|
+
if not UtilClient.is_unset(request.session_id):
|
|
899
|
+
query['SessionId'] = request.session_id
|
|
900
|
+
req = open_api_models.OpenApiRequest(
|
|
901
|
+
query=OpenApiUtilClient.query(query)
|
|
902
|
+
)
|
|
903
|
+
params = open_api_models.Params(
|
|
904
|
+
action='EncryptPassword',
|
|
905
|
+
version='2020-10-02',
|
|
906
|
+
protocol='HTTPS',
|
|
907
|
+
pathname='/',
|
|
908
|
+
method='POST',
|
|
909
|
+
auth_type='Anonymous',
|
|
910
|
+
style='RPC',
|
|
911
|
+
req_body_type='formData',
|
|
912
|
+
body_type='json'
|
|
913
|
+
)
|
|
914
|
+
return TeaCore.from_map(
|
|
915
|
+
ecd_20201002_models.EncryptPasswordResponse(),
|
|
916
|
+
self.call_api(params, req, runtime)
|
|
917
|
+
)
|
|
918
|
+
|
|
919
|
+
async def encrypt_password_with_options_async(
|
|
920
|
+
self,
|
|
921
|
+
request: ecd_20201002_models.EncryptPasswordRequest,
|
|
922
|
+
runtime: util_models.RuntimeOptions,
|
|
923
|
+
) -> ecd_20201002_models.EncryptPasswordResponse:
|
|
924
|
+
UtilClient.validate_model(request)
|
|
925
|
+
query = {}
|
|
926
|
+
if not UtilClient.is_unset(request.client_id):
|
|
927
|
+
query['ClientId'] = request.client_id
|
|
928
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
929
|
+
query['DirectoryId'] = request.directory_id
|
|
930
|
+
if not UtilClient.is_unset(request.login_token):
|
|
931
|
+
query['LoginToken'] = request.login_token
|
|
932
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
933
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
934
|
+
if not UtilClient.is_unset(request.password):
|
|
935
|
+
query['Password'] = request.password
|
|
936
|
+
if not UtilClient.is_unset(request.region_id):
|
|
937
|
+
query['RegionId'] = request.region_id
|
|
938
|
+
if not UtilClient.is_unset(request.session_id):
|
|
939
|
+
query['SessionId'] = request.session_id
|
|
940
|
+
req = open_api_models.OpenApiRequest(
|
|
941
|
+
query=OpenApiUtilClient.query(query)
|
|
942
|
+
)
|
|
943
|
+
params = open_api_models.Params(
|
|
944
|
+
action='EncryptPassword',
|
|
945
|
+
version='2020-10-02',
|
|
946
|
+
protocol='HTTPS',
|
|
947
|
+
pathname='/',
|
|
948
|
+
method='POST',
|
|
949
|
+
auth_type='Anonymous',
|
|
950
|
+
style='RPC',
|
|
951
|
+
req_body_type='formData',
|
|
952
|
+
body_type='json'
|
|
953
|
+
)
|
|
954
|
+
return TeaCore.from_map(
|
|
955
|
+
ecd_20201002_models.EncryptPasswordResponse(),
|
|
956
|
+
await self.call_api_async(params, req, runtime)
|
|
957
|
+
)
|
|
958
|
+
|
|
959
|
+
def encrypt_password(
|
|
960
|
+
self,
|
|
961
|
+
request: ecd_20201002_models.EncryptPasswordRequest,
|
|
962
|
+
) -> ecd_20201002_models.EncryptPasswordResponse:
|
|
963
|
+
runtime = util_models.RuntimeOptions()
|
|
964
|
+
return self.encrypt_password_with_options(request, runtime)
|
|
965
|
+
|
|
966
|
+
async def encrypt_password_async(
|
|
967
|
+
self,
|
|
968
|
+
request: ecd_20201002_models.EncryptPasswordRequest,
|
|
969
|
+
) -> ecd_20201002_models.EncryptPasswordResponse:
|
|
970
|
+
runtime = util_models.RuntimeOptions()
|
|
971
|
+
return await self.encrypt_password_with_options_async(request, runtime)
|
|
972
|
+
|
|
973
|
+
def get_cloud_drive_service_mount_token_with_options(
|
|
974
|
+
self,
|
|
975
|
+
request: ecd_20201002_models.GetCloudDriveServiceMountTokenRequest,
|
|
976
|
+
runtime: util_models.RuntimeOptions,
|
|
977
|
+
) -> ecd_20201002_models.GetCloudDriveServiceMountTokenResponse:
|
|
978
|
+
UtilClient.validate_model(request)
|
|
979
|
+
query = {}
|
|
980
|
+
if not UtilClient.is_unset(request.client_id):
|
|
981
|
+
query['ClientId'] = request.client_id
|
|
982
|
+
if not UtilClient.is_unset(request.login_token):
|
|
983
|
+
query['LoginToken'] = request.login_token
|
|
984
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
985
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
986
|
+
if not UtilClient.is_unset(request.region_id):
|
|
987
|
+
query['RegionId'] = request.region_id
|
|
988
|
+
if not UtilClient.is_unset(request.session_id):
|
|
989
|
+
query['SessionId'] = request.session_id
|
|
990
|
+
req = open_api_models.OpenApiRequest(
|
|
991
|
+
query=OpenApiUtilClient.query(query)
|
|
992
|
+
)
|
|
993
|
+
params = open_api_models.Params(
|
|
994
|
+
action='GetCloudDriveServiceMountToken',
|
|
995
|
+
version='2020-10-02',
|
|
996
|
+
protocol='HTTPS',
|
|
997
|
+
pathname='/',
|
|
998
|
+
method='POST',
|
|
999
|
+
auth_type='Anonymous',
|
|
1000
|
+
style='RPC',
|
|
1001
|
+
req_body_type='formData',
|
|
1002
|
+
body_type='json'
|
|
1003
|
+
)
|
|
1004
|
+
return TeaCore.from_map(
|
|
1005
|
+
ecd_20201002_models.GetCloudDriveServiceMountTokenResponse(),
|
|
1006
|
+
self.call_api(params, req, runtime)
|
|
1007
|
+
)
|
|
1008
|
+
|
|
1009
|
+
async def get_cloud_drive_service_mount_token_with_options_async(
|
|
1010
|
+
self,
|
|
1011
|
+
request: ecd_20201002_models.GetCloudDriveServiceMountTokenRequest,
|
|
1012
|
+
runtime: util_models.RuntimeOptions,
|
|
1013
|
+
) -> ecd_20201002_models.GetCloudDriveServiceMountTokenResponse:
|
|
1014
|
+
UtilClient.validate_model(request)
|
|
1015
|
+
query = {}
|
|
1016
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1017
|
+
query['ClientId'] = request.client_id
|
|
1018
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1019
|
+
query['LoginToken'] = request.login_token
|
|
1020
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1021
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1022
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1023
|
+
query['RegionId'] = request.region_id
|
|
1024
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1025
|
+
query['SessionId'] = request.session_id
|
|
1026
|
+
req = open_api_models.OpenApiRequest(
|
|
1027
|
+
query=OpenApiUtilClient.query(query)
|
|
1028
|
+
)
|
|
1029
|
+
params = open_api_models.Params(
|
|
1030
|
+
action='GetCloudDriveServiceMountToken',
|
|
1031
|
+
version='2020-10-02',
|
|
1032
|
+
protocol='HTTPS',
|
|
1033
|
+
pathname='/',
|
|
1034
|
+
method='POST',
|
|
1035
|
+
auth_type='Anonymous',
|
|
1036
|
+
style='RPC',
|
|
1037
|
+
req_body_type='formData',
|
|
1038
|
+
body_type='json'
|
|
1039
|
+
)
|
|
1040
|
+
return TeaCore.from_map(
|
|
1041
|
+
ecd_20201002_models.GetCloudDriveServiceMountTokenResponse(),
|
|
1042
|
+
await self.call_api_async(params, req, runtime)
|
|
1043
|
+
)
|
|
1044
|
+
|
|
1045
|
+
def get_cloud_drive_service_mount_token(
|
|
1046
|
+
self,
|
|
1047
|
+
request: ecd_20201002_models.GetCloudDriveServiceMountTokenRequest,
|
|
1048
|
+
) -> ecd_20201002_models.GetCloudDriveServiceMountTokenResponse:
|
|
1049
|
+
runtime = util_models.RuntimeOptions()
|
|
1050
|
+
return self.get_cloud_drive_service_mount_token_with_options(request, runtime)
|
|
1051
|
+
|
|
1052
|
+
async def get_cloud_drive_service_mount_token_async(
|
|
1053
|
+
self,
|
|
1054
|
+
request: ecd_20201002_models.GetCloudDriveServiceMountTokenRequest,
|
|
1055
|
+
) -> ecd_20201002_models.GetCloudDriveServiceMountTokenResponse:
|
|
1056
|
+
runtime = util_models.RuntimeOptions()
|
|
1057
|
+
return await self.get_cloud_drive_service_mount_token_with_options_async(request, runtime)
|
|
1058
|
+
|
|
1059
|
+
def get_connection_ticket_with_options(
|
|
1060
|
+
self,
|
|
1061
|
+
request: ecd_20201002_models.GetConnectionTicketRequest,
|
|
1062
|
+
runtime: util_models.RuntimeOptions,
|
|
1063
|
+
) -> ecd_20201002_models.GetConnectionTicketResponse:
|
|
1064
|
+
UtilClient.validate_model(request)
|
|
1065
|
+
query = {}
|
|
1066
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1067
|
+
query['ClientId'] = request.client_id
|
|
1068
|
+
if not UtilClient.is_unset(request.client_os):
|
|
1069
|
+
query['ClientOS'] = request.client_os
|
|
1070
|
+
if not UtilClient.is_unset(request.client_type):
|
|
1071
|
+
query['ClientType'] = request.client_type
|
|
1072
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1073
|
+
query['ClientVersion'] = request.client_version
|
|
1074
|
+
if not UtilClient.is_unset(request.command_content):
|
|
1075
|
+
query['CommandContent'] = request.command_content
|
|
1076
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1077
|
+
query['DesktopId'] = request.desktop_id
|
|
1078
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1079
|
+
query['LoginToken'] = request.login_token
|
|
1080
|
+
if not UtilClient.is_unset(request.owner_id):
|
|
1081
|
+
query['OwnerId'] = request.owner_id
|
|
1082
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1083
|
+
query['RegionId'] = request.region_id
|
|
1084
|
+
if not UtilClient.is_unset(request.resource_owner_account):
|
|
1085
|
+
query['ResourceOwnerAccount'] = request.resource_owner_account
|
|
1086
|
+
if not UtilClient.is_unset(request.resource_owner_id):
|
|
1087
|
+
query['ResourceOwnerId'] = request.resource_owner_id
|
|
1088
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1089
|
+
query['SessionId'] = request.session_id
|
|
1090
|
+
if not UtilClient.is_unset(request.task_id):
|
|
1091
|
+
query['TaskId'] = request.task_id
|
|
1092
|
+
if not UtilClient.is_unset(request.uuid):
|
|
1093
|
+
query['Uuid'] = request.uuid
|
|
1094
|
+
req = open_api_models.OpenApiRequest(
|
|
1095
|
+
query=OpenApiUtilClient.query(query)
|
|
1096
|
+
)
|
|
1097
|
+
params = open_api_models.Params(
|
|
1098
|
+
action='GetConnectionTicket',
|
|
1099
|
+
version='2020-10-02',
|
|
1100
|
+
protocol='HTTPS',
|
|
1101
|
+
pathname='/',
|
|
1102
|
+
method='POST',
|
|
1103
|
+
auth_type='Anonymous',
|
|
1104
|
+
style='RPC',
|
|
1105
|
+
req_body_type='formData',
|
|
1106
|
+
body_type='json'
|
|
1107
|
+
)
|
|
1108
|
+
return TeaCore.from_map(
|
|
1109
|
+
ecd_20201002_models.GetConnectionTicketResponse(),
|
|
1110
|
+
self.call_api(params, req, runtime)
|
|
1111
|
+
)
|
|
1112
|
+
|
|
1113
|
+
async def get_connection_ticket_with_options_async(
|
|
1114
|
+
self,
|
|
1115
|
+
request: ecd_20201002_models.GetConnectionTicketRequest,
|
|
1116
|
+
runtime: util_models.RuntimeOptions,
|
|
1117
|
+
) -> ecd_20201002_models.GetConnectionTicketResponse:
|
|
1118
|
+
UtilClient.validate_model(request)
|
|
1119
|
+
query = {}
|
|
1120
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1121
|
+
query['ClientId'] = request.client_id
|
|
1122
|
+
if not UtilClient.is_unset(request.client_os):
|
|
1123
|
+
query['ClientOS'] = request.client_os
|
|
1124
|
+
if not UtilClient.is_unset(request.client_type):
|
|
1125
|
+
query['ClientType'] = request.client_type
|
|
1126
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1127
|
+
query['ClientVersion'] = request.client_version
|
|
1128
|
+
if not UtilClient.is_unset(request.command_content):
|
|
1129
|
+
query['CommandContent'] = request.command_content
|
|
1130
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1131
|
+
query['DesktopId'] = request.desktop_id
|
|
1132
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1133
|
+
query['LoginToken'] = request.login_token
|
|
1134
|
+
if not UtilClient.is_unset(request.owner_id):
|
|
1135
|
+
query['OwnerId'] = request.owner_id
|
|
1136
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1137
|
+
query['RegionId'] = request.region_id
|
|
1138
|
+
if not UtilClient.is_unset(request.resource_owner_account):
|
|
1139
|
+
query['ResourceOwnerAccount'] = request.resource_owner_account
|
|
1140
|
+
if not UtilClient.is_unset(request.resource_owner_id):
|
|
1141
|
+
query['ResourceOwnerId'] = request.resource_owner_id
|
|
1142
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1143
|
+
query['SessionId'] = request.session_id
|
|
1144
|
+
if not UtilClient.is_unset(request.task_id):
|
|
1145
|
+
query['TaskId'] = request.task_id
|
|
1146
|
+
if not UtilClient.is_unset(request.uuid):
|
|
1147
|
+
query['Uuid'] = request.uuid
|
|
1148
|
+
req = open_api_models.OpenApiRequest(
|
|
1149
|
+
query=OpenApiUtilClient.query(query)
|
|
1150
|
+
)
|
|
1151
|
+
params = open_api_models.Params(
|
|
1152
|
+
action='GetConnectionTicket',
|
|
1153
|
+
version='2020-10-02',
|
|
1154
|
+
protocol='HTTPS',
|
|
1155
|
+
pathname='/',
|
|
1156
|
+
method='POST',
|
|
1157
|
+
auth_type='Anonymous',
|
|
1158
|
+
style='RPC',
|
|
1159
|
+
req_body_type='formData',
|
|
1160
|
+
body_type='json'
|
|
1161
|
+
)
|
|
1162
|
+
return TeaCore.from_map(
|
|
1163
|
+
ecd_20201002_models.GetConnectionTicketResponse(),
|
|
1164
|
+
await self.call_api_async(params, req, runtime)
|
|
1165
|
+
)
|
|
1166
|
+
|
|
1167
|
+
def get_connection_ticket(
|
|
1168
|
+
self,
|
|
1169
|
+
request: ecd_20201002_models.GetConnectionTicketRequest,
|
|
1170
|
+
) -> ecd_20201002_models.GetConnectionTicketResponse:
|
|
1171
|
+
runtime = util_models.RuntimeOptions()
|
|
1172
|
+
return self.get_connection_ticket_with_options(request, runtime)
|
|
1173
|
+
|
|
1174
|
+
async def get_connection_ticket_async(
|
|
1175
|
+
self,
|
|
1176
|
+
request: ecd_20201002_models.GetConnectionTicketRequest,
|
|
1177
|
+
) -> ecd_20201002_models.GetConnectionTicketResponse:
|
|
1178
|
+
runtime = util_models.RuntimeOptions()
|
|
1179
|
+
return await self.get_connection_ticket_with_options_async(request, runtime)
|
|
1180
|
+
|
|
1181
|
+
def get_login_token_with_options(
|
|
1182
|
+
self,
|
|
1183
|
+
request: ecd_20201002_models.GetLoginTokenRequest,
|
|
1184
|
+
runtime: util_models.RuntimeOptions,
|
|
1185
|
+
) -> ecd_20201002_models.GetLoginTokenResponse:
|
|
1186
|
+
UtilClient.validate_model(request)
|
|
1187
|
+
query = {}
|
|
1188
|
+
if not UtilClient.is_unset(request.authentication_code):
|
|
1189
|
+
query['AuthenticationCode'] = request.authentication_code
|
|
1190
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1191
|
+
query['ClientId'] = request.client_id
|
|
1192
|
+
if not UtilClient.is_unset(request.client_os):
|
|
1193
|
+
query['ClientOS'] = request.client_os
|
|
1194
|
+
if not UtilClient.is_unset(request.client_type):
|
|
1195
|
+
query['ClientType'] = request.client_type
|
|
1196
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1197
|
+
query['ClientVersion'] = request.client_version
|
|
1198
|
+
if not UtilClient.is_unset(request.current_stage):
|
|
1199
|
+
query['CurrentStage'] = request.current_stage
|
|
1200
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
1201
|
+
query['DirectoryId'] = request.directory_id
|
|
1202
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1203
|
+
query['EndUserId'] = request.end_user_id
|
|
1204
|
+
if not UtilClient.is_unset(request.keep_alive):
|
|
1205
|
+
query['KeepAlive'] = request.keep_alive
|
|
1206
|
+
if not UtilClient.is_unset(request.keep_alive_token):
|
|
1207
|
+
query['KeepAliveToken'] = request.keep_alive_token
|
|
1208
|
+
if not UtilClient.is_unset(request.new_password):
|
|
1209
|
+
query['NewPassword'] = request.new_password
|
|
1210
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1211
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1212
|
+
if not UtilClient.is_unset(request.old_password):
|
|
1213
|
+
query['OldPassword'] = request.old_password
|
|
1214
|
+
if not UtilClient.is_unset(request.password):
|
|
1215
|
+
query['Password'] = request.password
|
|
1216
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1217
|
+
query['RegionId'] = request.region_id
|
|
1218
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1219
|
+
query['SessionId'] = request.session_id
|
|
1220
|
+
if not UtilClient.is_unset(request.token_code):
|
|
1221
|
+
query['TokenCode'] = request.token_code
|
|
1222
|
+
if not UtilClient.is_unset(request.uuid):
|
|
1223
|
+
query['Uuid'] = request.uuid
|
|
1224
|
+
req = open_api_models.OpenApiRequest(
|
|
1225
|
+
query=OpenApiUtilClient.query(query)
|
|
1226
|
+
)
|
|
1227
|
+
params = open_api_models.Params(
|
|
1228
|
+
action='GetLoginToken',
|
|
1229
|
+
version='2020-10-02',
|
|
1230
|
+
protocol='HTTPS',
|
|
1231
|
+
pathname='/',
|
|
1232
|
+
method='POST',
|
|
1233
|
+
auth_type='Anonymous',
|
|
1234
|
+
style='RPC',
|
|
1235
|
+
req_body_type='formData',
|
|
1236
|
+
body_type='json'
|
|
1237
|
+
)
|
|
1238
|
+
return TeaCore.from_map(
|
|
1239
|
+
ecd_20201002_models.GetLoginTokenResponse(),
|
|
1240
|
+
self.call_api(params, req, runtime)
|
|
1241
|
+
)
|
|
1242
|
+
|
|
1243
|
+
async def get_login_token_with_options_async(
|
|
1244
|
+
self,
|
|
1245
|
+
request: ecd_20201002_models.GetLoginTokenRequest,
|
|
1246
|
+
runtime: util_models.RuntimeOptions,
|
|
1247
|
+
) -> ecd_20201002_models.GetLoginTokenResponse:
|
|
1248
|
+
UtilClient.validate_model(request)
|
|
1249
|
+
query = {}
|
|
1250
|
+
if not UtilClient.is_unset(request.authentication_code):
|
|
1251
|
+
query['AuthenticationCode'] = request.authentication_code
|
|
1252
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1253
|
+
query['ClientId'] = request.client_id
|
|
1254
|
+
if not UtilClient.is_unset(request.client_os):
|
|
1255
|
+
query['ClientOS'] = request.client_os
|
|
1256
|
+
if not UtilClient.is_unset(request.client_type):
|
|
1257
|
+
query['ClientType'] = request.client_type
|
|
1258
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1259
|
+
query['ClientVersion'] = request.client_version
|
|
1260
|
+
if not UtilClient.is_unset(request.current_stage):
|
|
1261
|
+
query['CurrentStage'] = request.current_stage
|
|
1262
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
1263
|
+
query['DirectoryId'] = request.directory_id
|
|
1264
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1265
|
+
query['EndUserId'] = request.end_user_id
|
|
1266
|
+
if not UtilClient.is_unset(request.keep_alive):
|
|
1267
|
+
query['KeepAlive'] = request.keep_alive
|
|
1268
|
+
if not UtilClient.is_unset(request.keep_alive_token):
|
|
1269
|
+
query['KeepAliveToken'] = request.keep_alive_token
|
|
1270
|
+
if not UtilClient.is_unset(request.new_password):
|
|
1271
|
+
query['NewPassword'] = request.new_password
|
|
1272
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1273
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1274
|
+
if not UtilClient.is_unset(request.old_password):
|
|
1275
|
+
query['OldPassword'] = request.old_password
|
|
1276
|
+
if not UtilClient.is_unset(request.password):
|
|
1277
|
+
query['Password'] = request.password
|
|
1278
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1279
|
+
query['RegionId'] = request.region_id
|
|
1280
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1281
|
+
query['SessionId'] = request.session_id
|
|
1282
|
+
if not UtilClient.is_unset(request.token_code):
|
|
1283
|
+
query['TokenCode'] = request.token_code
|
|
1284
|
+
if not UtilClient.is_unset(request.uuid):
|
|
1285
|
+
query['Uuid'] = request.uuid
|
|
1286
|
+
req = open_api_models.OpenApiRequest(
|
|
1287
|
+
query=OpenApiUtilClient.query(query)
|
|
1288
|
+
)
|
|
1289
|
+
params = open_api_models.Params(
|
|
1290
|
+
action='GetLoginToken',
|
|
1291
|
+
version='2020-10-02',
|
|
1292
|
+
protocol='HTTPS',
|
|
1293
|
+
pathname='/',
|
|
1294
|
+
method='POST',
|
|
1295
|
+
auth_type='Anonymous',
|
|
1296
|
+
style='RPC',
|
|
1297
|
+
req_body_type='formData',
|
|
1298
|
+
body_type='json'
|
|
1299
|
+
)
|
|
1300
|
+
return TeaCore.from_map(
|
|
1301
|
+
ecd_20201002_models.GetLoginTokenResponse(),
|
|
1302
|
+
await self.call_api_async(params, req, runtime)
|
|
1303
|
+
)
|
|
1304
|
+
|
|
1305
|
+
def get_login_token(
|
|
1306
|
+
self,
|
|
1307
|
+
request: ecd_20201002_models.GetLoginTokenRequest,
|
|
1308
|
+
) -> ecd_20201002_models.GetLoginTokenResponse:
|
|
1309
|
+
runtime = util_models.RuntimeOptions()
|
|
1310
|
+
return self.get_login_token_with_options(request, runtime)
|
|
1311
|
+
|
|
1312
|
+
async def get_login_token_async(
|
|
1313
|
+
self,
|
|
1314
|
+
request: ecd_20201002_models.GetLoginTokenRequest,
|
|
1315
|
+
) -> ecd_20201002_models.GetLoginTokenResponse:
|
|
1316
|
+
runtime = util_models.RuntimeOptions()
|
|
1317
|
+
return await self.get_login_token_with_options_async(request, runtime)
|
|
1318
|
+
|
|
1319
|
+
def is_keep_alive_with_options(
|
|
1320
|
+
self,
|
|
1321
|
+
request: ecd_20201002_models.IsKeepAliveRequest,
|
|
1322
|
+
runtime: util_models.RuntimeOptions,
|
|
1323
|
+
) -> ecd_20201002_models.IsKeepAliveResponse:
|
|
1324
|
+
UtilClient.validate_model(request)
|
|
1325
|
+
query = {}
|
|
1326
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1327
|
+
query['ClientId'] = request.client_id
|
|
1328
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1329
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1330
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1331
|
+
query['RegionId'] = request.region_id
|
|
1332
|
+
req = open_api_models.OpenApiRequest(
|
|
1333
|
+
query=OpenApiUtilClient.query(query)
|
|
1334
|
+
)
|
|
1335
|
+
params = open_api_models.Params(
|
|
1336
|
+
action='IsKeepAlive',
|
|
1337
|
+
version='2020-10-02',
|
|
1338
|
+
protocol='HTTPS',
|
|
1339
|
+
pathname='/',
|
|
1340
|
+
method='POST',
|
|
1341
|
+
auth_type='Anonymous',
|
|
1342
|
+
style='RPC',
|
|
1343
|
+
req_body_type='formData',
|
|
1344
|
+
body_type='json'
|
|
1345
|
+
)
|
|
1346
|
+
return TeaCore.from_map(
|
|
1347
|
+
ecd_20201002_models.IsKeepAliveResponse(),
|
|
1348
|
+
self.call_api(params, req, runtime)
|
|
1349
|
+
)
|
|
1350
|
+
|
|
1351
|
+
async def is_keep_alive_with_options_async(
|
|
1352
|
+
self,
|
|
1353
|
+
request: ecd_20201002_models.IsKeepAliveRequest,
|
|
1354
|
+
runtime: util_models.RuntimeOptions,
|
|
1355
|
+
) -> ecd_20201002_models.IsKeepAliveResponse:
|
|
1356
|
+
UtilClient.validate_model(request)
|
|
1357
|
+
query = {}
|
|
1358
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1359
|
+
query['ClientId'] = request.client_id
|
|
1360
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1361
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1362
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1363
|
+
query['RegionId'] = request.region_id
|
|
1364
|
+
req = open_api_models.OpenApiRequest(
|
|
1365
|
+
query=OpenApiUtilClient.query(query)
|
|
1366
|
+
)
|
|
1367
|
+
params = open_api_models.Params(
|
|
1368
|
+
action='IsKeepAlive',
|
|
1369
|
+
version='2020-10-02',
|
|
1370
|
+
protocol='HTTPS',
|
|
1371
|
+
pathname='/',
|
|
1372
|
+
method='POST',
|
|
1373
|
+
auth_type='Anonymous',
|
|
1374
|
+
style='RPC',
|
|
1375
|
+
req_body_type='formData',
|
|
1376
|
+
body_type='json'
|
|
1377
|
+
)
|
|
1378
|
+
return TeaCore.from_map(
|
|
1379
|
+
ecd_20201002_models.IsKeepAliveResponse(),
|
|
1380
|
+
await self.call_api_async(params, req, runtime)
|
|
1381
|
+
)
|
|
1382
|
+
|
|
1383
|
+
def is_keep_alive(
|
|
1384
|
+
self,
|
|
1385
|
+
request: ecd_20201002_models.IsKeepAliveRequest,
|
|
1386
|
+
) -> ecd_20201002_models.IsKeepAliveResponse:
|
|
1387
|
+
runtime = util_models.RuntimeOptions()
|
|
1388
|
+
return self.is_keep_alive_with_options(request, runtime)
|
|
1389
|
+
|
|
1390
|
+
async def is_keep_alive_async(
|
|
1391
|
+
self,
|
|
1392
|
+
request: ecd_20201002_models.IsKeepAliveRequest,
|
|
1393
|
+
) -> ecd_20201002_models.IsKeepAliveResponse:
|
|
1394
|
+
runtime = util_models.RuntimeOptions()
|
|
1395
|
+
return await self.is_keep_alive_with_options_async(request, runtime)
|
|
1396
|
+
|
|
1397
|
+
def query_eds_agent_report_config_with_options(
|
|
1398
|
+
self,
|
|
1399
|
+
request: ecd_20201002_models.QueryEdsAgentReportConfigRequest,
|
|
1400
|
+
runtime: util_models.RuntimeOptions,
|
|
1401
|
+
) -> ecd_20201002_models.QueryEdsAgentReportConfigResponse:
|
|
1402
|
+
UtilClient.validate_model(request)
|
|
1403
|
+
query = {}
|
|
1404
|
+
if not UtilClient.is_unset(request.ali_uid):
|
|
1405
|
+
query['AliUid'] = request.ali_uid
|
|
1406
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1407
|
+
query['DesktopId'] = request.desktop_id
|
|
1408
|
+
if not UtilClient.is_unset(request.ecs_instance_id):
|
|
1409
|
+
query['EcsInstanceId'] = request.ecs_instance_id
|
|
1410
|
+
req = open_api_models.OpenApiRequest(
|
|
1411
|
+
query=OpenApiUtilClient.query(query)
|
|
1412
|
+
)
|
|
1413
|
+
params = open_api_models.Params(
|
|
1414
|
+
action='QueryEdsAgentReportConfig',
|
|
1415
|
+
version='2020-10-02',
|
|
1416
|
+
protocol='HTTPS',
|
|
1417
|
+
pathname='/',
|
|
1418
|
+
method='POST',
|
|
1419
|
+
auth_type='Anonymous',
|
|
1420
|
+
style='RPC',
|
|
1421
|
+
req_body_type='formData',
|
|
1422
|
+
body_type='json'
|
|
1423
|
+
)
|
|
1424
|
+
return TeaCore.from_map(
|
|
1425
|
+
ecd_20201002_models.QueryEdsAgentReportConfigResponse(),
|
|
1426
|
+
self.call_api(params, req, runtime)
|
|
1427
|
+
)
|
|
1428
|
+
|
|
1429
|
+
async def query_eds_agent_report_config_with_options_async(
|
|
1430
|
+
self,
|
|
1431
|
+
request: ecd_20201002_models.QueryEdsAgentReportConfigRequest,
|
|
1432
|
+
runtime: util_models.RuntimeOptions,
|
|
1433
|
+
) -> ecd_20201002_models.QueryEdsAgentReportConfigResponse:
|
|
1434
|
+
UtilClient.validate_model(request)
|
|
1435
|
+
query = {}
|
|
1436
|
+
if not UtilClient.is_unset(request.ali_uid):
|
|
1437
|
+
query['AliUid'] = request.ali_uid
|
|
1438
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1439
|
+
query['DesktopId'] = request.desktop_id
|
|
1440
|
+
if not UtilClient.is_unset(request.ecs_instance_id):
|
|
1441
|
+
query['EcsInstanceId'] = request.ecs_instance_id
|
|
1442
|
+
req = open_api_models.OpenApiRequest(
|
|
1443
|
+
query=OpenApiUtilClient.query(query)
|
|
1444
|
+
)
|
|
1445
|
+
params = open_api_models.Params(
|
|
1446
|
+
action='QueryEdsAgentReportConfig',
|
|
1447
|
+
version='2020-10-02',
|
|
1448
|
+
protocol='HTTPS',
|
|
1449
|
+
pathname='/',
|
|
1450
|
+
method='POST',
|
|
1451
|
+
auth_type='Anonymous',
|
|
1452
|
+
style='RPC',
|
|
1453
|
+
req_body_type='formData',
|
|
1454
|
+
body_type='json'
|
|
1455
|
+
)
|
|
1456
|
+
return TeaCore.from_map(
|
|
1457
|
+
ecd_20201002_models.QueryEdsAgentReportConfigResponse(),
|
|
1458
|
+
await self.call_api_async(params, req, runtime)
|
|
1459
|
+
)
|
|
1460
|
+
|
|
1461
|
+
def query_eds_agent_report_config(
|
|
1462
|
+
self,
|
|
1463
|
+
request: ecd_20201002_models.QueryEdsAgentReportConfigRequest,
|
|
1464
|
+
) -> ecd_20201002_models.QueryEdsAgentReportConfigResponse:
|
|
1465
|
+
runtime = util_models.RuntimeOptions()
|
|
1466
|
+
return self.query_eds_agent_report_config_with_options(request, runtime)
|
|
1467
|
+
|
|
1468
|
+
async def query_eds_agent_report_config_async(
|
|
1469
|
+
self,
|
|
1470
|
+
request: ecd_20201002_models.QueryEdsAgentReportConfigRequest,
|
|
1471
|
+
) -> ecd_20201002_models.QueryEdsAgentReportConfigResponse:
|
|
1472
|
+
runtime = util_models.RuntimeOptions()
|
|
1473
|
+
return await self.query_eds_agent_report_config_with_options_async(request, runtime)
|
|
1474
|
+
|
|
1475
|
+
def reboot_desktops_with_options(
|
|
1476
|
+
self,
|
|
1477
|
+
request: ecd_20201002_models.RebootDesktopsRequest,
|
|
1478
|
+
runtime: util_models.RuntimeOptions,
|
|
1479
|
+
) -> ecd_20201002_models.RebootDesktopsResponse:
|
|
1480
|
+
UtilClient.validate_model(request)
|
|
1481
|
+
query = {}
|
|
1482
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1483
|
+
query['ClientId'] = request.client_id
|
|
1484
|
+
if not UtilClient.is_unset(request.client_os):
|
|
1485
|
+
query['ClientOS'] = request.client_os
|
|
1486
|
+
if not UtilClient.is_unset(request.client_token):
|
|
1487
|
+
query['ClientToken'] = request.client_token
|
|
1488
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1489
|
+
query['ClientVersion'] = request.client_version
|
|
1490
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1491
|
+
query['DesktopId'] = request.desktop_id
|
|
1492
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1493
|
+
query['LoginToken'] = request.login_token
|
|
1494
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1495
|
+
query['RegionId'] = request.region_id
|
|
1496
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1497
|
+
query['SessionId'] = request.session_id
|
|
1498
|
+
if not UtilClient.is_unset(request.session_token):
|
|
1499
|
+
query['SessionToken'] = request.session_token
|
|
1500
|
+
req = open_api_models.OpenApiRequest(
|
|
1501
|
+
query=OpenApiUtilClient.query(query)
|
|
1502
|
+
)
|
|
1503
|
+
params = open_api_models.Params(
|
|
1504
|
+
action='RebootDesktops',
|
|
1505
|
+
version='2020-10-02',
|
|
1506
|
+
protocol='HTTPS',
|
|
1507
|
+
pathname='/',
|
|
1508
|
+
method='POST',
|
|
1509
|
+
auth_type='Anonymous',
|
|
1510
|
+
style='RPC',
|
|
1511
|
+
req_body_type='formData',
|
|
1512
|
+
body_type='json'
|
|
1513
|
+
)
|
|
1514
|
+
return TeaCore.from_map(
|
|
1515
|
+
ecd_20201002_models.RebootDesktopsResponse(),
|
|
1516
|
+
self.call_api(params, req, runtime)
|
|
1517
|
+
)
|
|
1518
|
+
|
|
1519
|
+
async def reboot_desktops_with_options_async(
|
|
1520
|
+
self,
|
|
1521
|
+
request: ecd_20201002_models.RebootDesktopsRequest,
|
|
1522
|
+
runtime: util_models.RuntimeOptions,
|
|
1523
|
+
) -> ecd_20201002_models.RebootDesktopsResponse:
|
|
1524
|
+
UtilClient.validate_model(request)
|
|
1525
|
+
query = {}
|
|
1526
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1527
|
+
query['ClientId'] = request.client_id
|
|
1528
|
+
if not UtilClient.is_unset(request.client_os):
|
|
1529
|
+
query['ClientOS'] = request.client_os
|
|
1530
|
+
if not UtilClient.is_unset(request.client_token):
|
|
1531
|
+
query['ClientToken'] = request.client_token
|
|
1532
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1533
|
+
query['ClientVersion'] = request.client_version
|
|
1534
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1535
|
+
query['DesktopId'] = request.desktop_id
|
|
1536
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1537
|
+
query['LoginToken'] = request.login_token
|
|
1538
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1539
|
+
query['RegionId'] = request.region_id
|
|
1540
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1541
|
+
query['SessionId'] = request.session_id
|
|
1542
|
+
if not UtilClient.is_unset(request.session_token):
|
|
1543
|
+
query['SessionToken'] = request.session_token
|
|
1544
|
+
req = open_api_models.OpenApiRequest(
|
|
1545
|
+
query=OpenApiUtilClient.query(query)
|
|
1546
|
+
)
|
|
1547
|
+
params = open_api_models.Params(
|
|
1548
|
+
action='RebootDesktops',
|
|
1549
|
+
version='2020-10-02',
|
|
1550
|
+
protocol='HTTPS',
|
|
1551
|
+
pathname='/',
|
|
1552
|
+
method='POST',
|
|
1553
|
+
auth_type='Anonymous',
|
|
1554
|
+
style='RPC',
|
|
1555
|
+
req_body_type='formData',
|
|
1556
|
+
body_type='json'
|
|
1557
|
+
)
|
|
1558
|
+
return TeaCore.from_map(
|
|
1559
|
+
ecd_20201002_models.RebootDesktopsResponse(),
|
|
1560
|
+
await self.call_api_async(params, req, runtime)
|
|
1561
|
+
)
|
|
1562
|
+
|
|
1563
|
+
def reboot_desktops(
|
|
1564
|
+
self,
|
|
1565
|
+
request: ecd_20201002_models.RebootDesktopsRequest,
|
|
1566
|
+
) -> ecd_20201002_models.RebootDesktopsResponse:
|
|
1567
|
+
runtime = util_models.RuntimeOptions()
|
|
1568
|
+
return self.reboot_desktops_with_options(request, runtime)
|
|
1569
|
+
|
|
1570
|
+
async def reboot_desktops_async(
|
|
1571
|
+
self,
|
|
1572
|
+
request: ecd_20201002_models.RebootDesktopsRequest,
|
|
1573
|
+
) -> ecd_20201002_models.RebootDesktopsResponse:
|
|
1574
|
+
runtime = util_models.RuntimeOptions()
|
|
1575
|
+
return await self.reboot_desktops_with_options_async(request, runtime)
|
|
1576
|
+
|
|
1577
|
+
def refresh_login_token_with_options(
|
|
1578
|
+
self,
|
|
1579
|
+
request: ecd_20201002_models.RefreshLoginTokenRequest,
|
|
1580
|
+
runtime: util_models.RuntimeOptions,
|
|
1581
|
+
) -> ecd_20201002_models.RefreshLoginTokenResponse:
|
|
1582
|
+
UtilClient.validate_model(request)
|
|
1583
|
+
query = {}
|
|
1584
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1585
|
+
query['ClientId'] = request.client_id
|
|
1586
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
1587
|
+
query['DirectoryId'] = request.directory_id
|
|
1588
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1589
|
+
query['EndUserId'] = request.end_user_id
|
|
1590
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1591
|
+
query['LoginToken'] = request.login_token
|
|
1592
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1593
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1594
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1595
|
+
query['RegionId'] = request.region_id
|
|
1596
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1597
|
+
query['SessionId'] = request.session_id
|
|
1598
|
+
req = open_api_models.OpenApiRequest(
|
|
1599
|
+
query=OpenApiUtilClient.query(query)
|
|
1600
|
+
)
|
|
1601
|
+
params = open_api_models.Params(
|
|
1602
|
+
action='RefreshLoginToken',
|
|
1603
|
+
version='2020-10-02',
|
|
1604
|
+
protocol='HTTPS',
|
|
1605
|
+
pathname='/',
|
|
1606
|
+
method='POST',
|
|
1607
|
+
auth_type='Anonymous',
|
|
1608
|
+
style='RPC',
|
|
1609
|
+
req_body_type='formData',
|
|
1610
|
+
body_type='json'
|
|
1611
|
+
)
|
|
1612
|
+
return TeaCore.from_map(
|
|
1613
|
+
ecd_20201002_models.RefreshLoginTokenResponse(),
|
|
1614
|
+
self.call_api(params, req, runtime)
|
|
1615
|
+
)
|
|
1616
|
+
|
|
1617
|
+
async def refresh_login_token_with_options_async(
|
|
1618
|
+
self,
|
|
1619
|
+
request: ecd_20201002_models.RefreshLoginTokenRequest,
|
|
1620
|
+
runtime: util_models.RuntimeOptions,
|
|
1621
|
+
) -> ecd_20201002_models.RefreshLoginTokenResponse:
|
|
1622
|
+
UtilClient.validate_model(request)
|
|
1623
|
+
query = {}
|
|
1624
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1625
|
+
query['ClientId'] = request.client_id
|
|
1626
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
1627
|
+
query['DirectoryId'] = request.directory_id
|
|
1628
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1629
|
+
query['EndUserId'] = request.end_user_id
|
|
1630
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1631
|
+
query['LoginToken'] = request.login_token
|
|
1632
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1633
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1634
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1635
|
+
query['RegionId'] = request.region_id
|
|
1636
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1637
|
+
query['SessionId'] = request.session_id
|
|
1638
|
+
req = open_api_models.OpenApiRequest(
|
|
1639
|
+
query=OpenApiUtilClient.query(query)
|
|
1640
|
+
)
|
|
1641
|
+
params = open_api_models.Params(
|
|
1642
|
+
action='RefreshLoginToken',
|
|
1643
|
+
version='2020-10-02',
|
|
1644
|
+
protocol='HTTPS',
|
|
1645
|
+
pathname='/',
|
|
1646
|
+
method='POST',
|
|
1647
|
+
auth_type='Anonymous',
|
|
1648
|
+
style='RPC',
|
|
1649
|
+
req_body_type='formData',
|
|
1650
|
+
body_type='json'
|
|
1651
|
+
)
|
|
1652
|
+
return TeaCore.from_map(
|
|
1653
|
+
ecd_20201002_models.RefreshLoginTokenResponse(),
|
|
1654
|
+
await self.call_api_async(params, req, runtime)
|
|
1655
|
+
)
|
|
1656
|
+
|
|
1657
|
+
def refresh_login_token(
|
|
1658
|
+
self,
|
|
1659
|
+
request: ecd_20201002_models.RefreshLoginTokenRequest,
|
|
1660
|
+
) -> ecd_20201002_models.RefreshLoginTokenResponse:
|
|
1661
|
+
runtime = util_models.RuntimeOptions()
|
|
1662
|
+
return self.refresh_login_token_with_options(request, runtime)
|
|
1663
|
+
|
|
1664
|
+
async def refresh_login_token_async(
|
|
1665
|
+
self,
|
|
1666
|
+
request: ecd_20201002_models.RefreshLoginTokenRequest,
|
|
1667
|
+
) -> ecd_20201002_models.RefreshLoginTokenResponse:
|
|
1668
|
+
runtime = util_models.RuntimeOptions()
|
|
1669
|
+
return await self.refresh_login_token_with_options_async(request, runtime)
|
|
1670
|
+
|
|
1671
|
+
def report_eds_agent_info_with_options(
|
|
1672
|
+
self,
|
|
1673
|
+
request: ecd_20201002_models.ReportEdsAgentInfoRequest,
|
|
1674
|
+
runtime: util_models.RuntimeOptions,
|
|
1675
|
+
) -> ecd_20201002_models.ReportEdsAgentInfoResponse:
|
|
1676
|
+
UtilClient.validate_model(request)
|
|
1677
|
+
query = {}
|
|
1678
|
+
if not UtilClient.is_unset(request.ali_uid):
|
|
1679
|
+
query['AliUid'] = request.ali_uid
|
|
1680
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1681
|
+
query['DesktopId'] = request.desktop_id
|
|
1682
|
+
if not UtilClient.is_unset(request.ecs_instance_id):
|
|
1683
|
+
query['EcsInstanceId'] = request.ecs_instance_id
|
|
1684
|
+
if not UtilClient.is_unset(request.eds_agent_info):
|
|
1685
|
+
query['EdsAgentInfo'] = request.eds_agent_info
|
|
1686
|
+
req = open_api_models.OpenApiRequest(
|
|
1687
|
+
query=OpenApiUtilClient.query(query)
|
|
1688
|
+
)
|
|
1689
|
+
params = open_api_models.Params(
|
|
1690
|
+
action='ReportEdsAgentInfo',
|
|
1691
|
+
version='2020-10-02',
|
|
1692
|
+
protocol='HTTPS',
|
|
1693
|
+
pathname='/',
|
|
1694
|
+
method='POST',
|
|
1695
|
+
auth_type='Anonymous',
|
|
1696
|
+
style='RPC',
|
|
1697
|
+
req_body_type='formData',
|
|
1698
|
+
body_type='json'
|
|
1699
|
+
)
|
|
1700
|
+
return TeaCore.from_map(
|
|
1701
|
+
ecd_20201002_models.ReportEdsAgentInfoResponse(),
|
|
1702
|
+
self.call_api(params, req, runtime)
|
|
1703
|
+
)
|
|
1704
|
+
|
|
1705
|
+
async def report_eds_agent_info_with_options_async(
|
|
1706
|
+
self,
|
|
1707
|
+
request: ecd_20201002_models.ReportEdsAgentInfoRequest,
|
|
1708
|
+
runtime: util_models.RuntimeOptions,
|
|
1709
|
+
) -> ecd_20201002_models.ReportEdsAgentInfoResponse:
|
|
1710
|
+
UtilClient.validate_model(request)
|
|
1711
|
+
query = {}
|
|
1712
|
+
if not UtilClient.is_unset(request.ali_uid):
|
|
1713
|
+
query['AliUid'] = request.ali_uid
|
|
1714
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1715
|
+
query['DesktopId'] = request.desktop_id
|
|
1716
|
+
if not UtilClient.is_unset(request.ecs_instance_id):
|
|
1717
|
+
query['EcsInstanceId'] = request.ecs_instance_id
|
|
1718
|
+
if not UtilClient.is_unset(request.eds_agent_info):
|
|
1719
|
+
query['EdsAgentInfo'] = request.eds_agent_info
|
|
1720
|
+
req = open_api_models.OpenApiRequest(
|
|
1721
|
+
query=OpenApiUtilClient.query(query)
|
|
1722
|
+
)
|
|
1723
|
+
params = open_api_models.Params(
|
|
1724
|
+
action='ReportEdsAgentInfo',
|
|
1725
|
+
version='2020-10-02',
|
|
1726
|
+
protocol='HTTPS',
|
|
1727
|
+
pathname='/',
|
|
1728
|
+
method='POST',
|
|
1729
|
+
auth_type='Anonymous',
|
|
1730
|
+
style='RPC',
|
|
1731
|
+
req_body_type='formData',
|
|
1732
|
+
body_type='json'
|
|
1733
|
+
)
|
|
1734
|
+
return TeaCore.from_map(
|
|
1735
|
+
ecd_20201002_models.ReportEdsAgentInfoResponse(),
|
|
1736
|
+
await self.call_api_async(params, req, runtime)
|
|
1737
|
+
)
|
|
1738
|
+
|
|
1739
|
+
def report_eds_agent_info(
|
|
1740
|
+
self,
|
|
1741
|
+
request: ecd_20201002_models.ReportEdsAgentInfoRequest,
|
|
1742
|
+
) -> ecd_20201002_models.ReportEdsAgentInfoResponse:
|
|
1743
|
+
runtime = util_models.RuntimeOptions()
|
|
1744
|
+
return self.report_eds_agent_info_with_options(request, runtime)
|
|
1745
|
+
|
|
1746
|
+
async def report_eds_agent_info_async(
|
|
1747
|
+
self,
|
|
1748
|
+
request: ecd_20201002_models.ReportEdsAgentInfoRequest,
|
|
1749
|
+
) -> ecd_20201002_models.ReportEdsAgentInfoResponse:
|
|
1750
|
+
runtime = util_models.RuntimeOptions()
|
|
1751
|
+
return await self.report_eds_agent_info_with_options_async(request, runtime)
|
|
1752
|
+
|
|
1753
|
+
def report_session_status_with_options(
|
|
1754
|
+
self,
|
|
1755
|
+
request: ecd_20201002_models.ReportSessionStatusRequest,
|
|
1756
|
+
runtime: util_models.RuntimeOptions,
|
|
1757
|
+
) -> ecd_20201002_models.ReportSessionStatusResponse:
|
|
1758
|
+
UtilClient.validate_model(request)
|
|
1759
|
+
query = {}
|
|
1760
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1761
|
+
query['EndUserId'] = request.end_user_id
|
|
1762
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
1763
|
+
query['InstanceId'] = request.instance_id
|
|
1764
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1765
|
+
query['RegionId'] = request.region_id
|
|
1766
|
+
if not UtilClient.is_unset(request.session_change_time):
|
|
1767
|
+
query['SessionChangeTime'] = request.session_change_time
|
|
1768
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1769
|
+
query['SessionId'] = request.session_id
|
|
1770
|
+
if not UtilClient.is_unset(request.session_status):
|
|
1771
|
+
query['SessionStatus'] = request.session_status
|
|
1772
|
+
req = open_api_models.OpenApiRequest(
|
|
1773
|
+
query=OpenApiUtilClient.query(query)
|
|
1774
|
+
)
|
|
1775
|
+
params = open_api_models.Params(
|
|
1776
|
+
action='ReportSessionStatus',
|
|
1777
|
+
version='2020-10-02',
|
|
1778
|
+
protocol='HTTPS',
|
|
1779
|
+
pathname='/',
|
|
1780
|
+
method='POST',
|
|
1781
|
+
auth_type='Anonymous',
|
|
1782
|
+
style='RPC',
|
|
1783
|
+
req_body_type='formData',
|
|
1784
|
+
body_type='json'
|
|
1785
|
+
)
|
|
1786
|
+
return TeaCore.from_map(
|
|
1787
|
+
ecd_20201002_models.ReportSessionStatusResponse(),
|
|
1788
|
+
self.call_api(params, req, runtime)
|
|
1789
|
+
)
|
|
1790
|
+
|
|
1791
|
+
async def report_session_status_with_options_async(
|
|
1792
|
+
self,
|
|
1793
|
+
request: ecd_20201002_models.ReportSessionStatusRequest,
|
|
1794
|
+
runtime: util_models.RuntimeOptions,
|
|
1795
|
+
) -> ecd_20201002_models.ReportSessionStatusResponse:
|
|
1796
|
+
UtilClient.validate_model(request)
|
|
1797
|
+
query = {}
|
|
1798
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1799
|
+
query['EndUserId'] = request.end_user_id
|
|
1800
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
1801
|
+
query['InstanceId'] = request.instance_id
|
|
1802
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1803
|
+
query['RegionId'] = request.region_id
|
|
1804
|
+
if not UtilClient.is_unset(request.session_change_time):
|
|
1805
|
+
query['SessionChangeTime'] = request.session_change_time
|
|
1806
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1807
|
+
query['SessionId'] = request.session_id
|
|
1808
|
+
if not UtilClient.is_unset(request.session_status):
|
|
1809
|
+
query['SessionStatus'] = request.session_status
|
|
1810
|
+
req = open_api_models.OpenApiRequest(
|
|
1811
|
+
query=OpenApiUtilClient.query(query)
|
|
1812
|
+
)
|
|
1813
|
+
params = open_api_models.Params(
|
|
1814
|
+
action='ReportSessionStatus',
|
|
1815
|
+
version='2020-10-02',
|
|
1816
|
+
protocol='HTTPS',
|
|
1817
|
+
pathname='/',
|
|
1818
|
+
method='POST',
|
|
1819
|
+
auth_type='Anonymous',
|
|
1820
|
+
style='RPC',
|
|
1821
|
+
req_body_type='formData',
|
|
1822
|
+
body_type='json'
|
|
1823
|
+
)
|
|
1824
|
+
return TeaCore.from_map(
|
|
1825
|
+
ecd_20201002_models.ReportSessionStatusResponse(),
|
|
1826
|
+
await self.call_api_async(params, req, runtime)
|
|
1827
|
+
)
|
|
1828
|
+
|
|
1829
|
+
def report_session_status(
|
|
1830
|
+
self,
|
|
1831
|
+
request: ecd_20201002_models.ReportSessionStatusRequest,
|
|
1832
|
+
) -> ecd_20201002_models.ReportSessionStatusResponse:
|
|
1833
|
+
runtime = util_models.RuntimeOptions()
|
|
1834
|
+
return self.report_session_status_with_options(request, runtime)
|
|
1835
|
+
|
|
1836
|
+
async def report_session_status_async(
|
|
1837
|
+
self,
|
|
1838
|
+
request: ecd_20201002_models.ReportSessionStatusRequest,
|
|
1839
|
+
) -> ecd_20201002_models.ReportSessionStatusResponse:
|
|
1840
|
+
runtime = util_models.RuntimeOptions()
|
|
1841
|
+
return await self.report_session_status_with_options_async(request, runtime)
|
|
1842
|
+
|
|
1843
|
+
def reset_password_with_options(
|
|
1844
|
+
self,
|
|
1845
|
+
request: ecd_20201002_models.ResetPasswordRequest,
|
|
1846
|
+
runtime: util_models.RuntimeOptions,
|
|
1847
|
+
) -> ecd_20201002_models.ResetPasswordResponse:
|
|
1848
|
+
UtilClient.validate_model(request)
|
|
1849
|
+
query = {}
|
|
1850
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1851
|
+
query['ClientId'] = request.client_id
|
|
1852
|
+
if not UtilClient.is_unset(request.client_token):
|
|
1853
|
+
query['ClientToken'] = request.client_token
|
|
1854
|
+
if not UtilClient.is_unset(request.email):
|
|
1855
|
+
query['Email'] = request.email
|
|
1856
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1857
|
+
query['EndUserId'] = request.end_user_id
|
|
1858
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1859
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1860
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1861
|
+
query['RegionId'] = request.region_id
|
|
1862
|
+
if not UtilClient.is_unset(request.phone):
|
|
1863
|
+
query['phone'] = request.phone
|
|
1864
|
+
req = open_api_models.OpenApiRequest(
|
|
1865
|
+
query=OpenApiUtilClient.query(query)
|
|
1866
|
+
)
|
|
1867
|
+
params = open_api_models.Params(
|
|
1868
|
+
action='ResetPassword',
|
|
1869
|
+
version='2020-10-02',
|
|
1870
|
+
protocol='HTTPS',
|
|
1871
|
+
pathname='/',
|
|
1872
|
+
method='POST',
|
|
1873
|
+
auth_type='Anonymous',
|
|
1874
|
+
style='RPC',
|
|
1875
|
+
req_body_type='formData',
|
|
1876
|
+
body_type='json'
|
|
1877
|
+
)
|
|
1878
|
+
return TeaCore.from_map(
|
|
1879
|
+
ecd_20201002_models.ResetPasswordResponse(),
|
|
1880
|
+
self.call_api(params, req, runtime)
|
|
1881
|
+
)
|
|
1882
|
+
|
|
1883
|
+
async def reset_password_with_options_async(
|
|
1884
|
+
self,
|
|
1885
|
+
request: ecd_20201002_models.ResetPasswordRequest,
|
|
1886
|
+
runtime: util_models.RuntimeOptions,
|
|
1887
|
+
) -> ecd_20201002_models.ResetPasswordResponse:
|
|
1888
|
+
UtilClient.validate_model(request)
|
|
1889
|
+
query = {}
|
|
1890
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1891
|
+
query['ClientId'] = request.client_id
|
|
1892
|
+
if not UtilClient.is_unset(request.client_token):
|
|
1893
|
+
query['ClientToken'] = request.client_token
|
|
1894
|
+
if not UtilClient.is_unset(request.email):
|
|
1895
|
+
query['Email'] = request.email
|
|
1896
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1897
|
+
query['EndUserId'] = request.end_user_id
|
|
1898
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1899
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1900
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1901
|
+
query['RegionId'] = request.region_id
|
|
1902
|
+
if not UtilClient.is_unset(request.phone):
|
|
1903
|
+
query['phone'] = request.phone
|
|
1904
|
+
req = open_api_models.OpenApiRequest(
|
|
1905
|
+
query=OpenApiUtilClient.query(query)
|
|
1906
|
+
)
|
|
1907
|
+
params = open_api_models.Params(
|
|
1908
|
+
action='ResetPassword',
|
|
1909
|
+
version='2020-10-02',
|
|
1910
|
+
protocol='HTTPS',
|
|
1911
|
+
pathname='/',
|
|
1912
|
+
method='POST',
|
|
1913
|
+
auth_type='Anonymous',
|
|
1914
|
+
style='RPC',
|
|
1915
|
+
req_body_type='formData',
|
|
1916
|
+
body_type='json'
|
|
1917
|
+
)
|
|
1918
|
+
return TeaCore.from_map(
|
|
1919
|
+
ecd_20201002_models.ResetPasswordResponse(),
|
|
1920
|
+
await self.call_api_async(params, req, runtime)
|
|
1921
|
+
)
|
|
1922
|
+
|
|
1923
|
+
def reset_password(
|
|
1924
|
+
self,
|
|
1925
|
+
request: ecd_20201002_models.ResetPasswordRequest,
|
|
1926
|
+
) -> ecd_20201002_models.ResetPasswordResponse:
|
|
1927
|
+
runtime = util_models.RuntimeOptions()
|
|
1928
|
+
return self.reset_password_with_options(request, runtime)
|
|
1929
|
+
|
|
1930
|
+
async def reset_password_async(
|
|
1931
|
+
self,
|
|
1932
|
+
request: ecd_20201002_models.ResetPasswordRequest,
|
|
1933
|
+
) -> ecd_20201002_models.ResetPasswordResponse:
|
|
1934
|
+
runtime = util_models.RuntimeOptions()
|
|
1935
|
+
return await self.reset_password_with_options_async(request, runtime)
|
|
1936
|
+
|
|
1937
|
+
def reset_snapshot_with_options(
|
|
1938
|
+
self,
|
|
1939
|
+
request: ecd_20201002_models.ResetSnapshotRequest,
|
|
1940
|
+
runtime: util_models.RuntimeOptions,
|
|
1941
|
+
) -> ecd_20201002_models.ResetSnapshotResponse:
|
|
1942
|
+
UtilClient.validate_model(request)
|
|
1943
|
+
query = {}
|
|
1944
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1945
|
+
query['ClientId'] = request.client_id
|
|
1946
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1947
|
+
query['LoginToken'] = request.login_token
|
|
1948
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1949
|
+
query['RegionId'] = request.region_id
|
|
1950
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1951
|
+
query['SessionId'] = request.session_id
|
|
1952
|
+
if not UtilClient.is_unset(request.snapshot_id):
|
|
1953
|
+
query['SnapshotId'] = request.snapshot_id
|
|
1954
|
+
req = open_api_models.OpenApiRequest(
|
|
1955
|
+
query=OpenApiUtilClient.query(query)
|
|
1956
|
+
)
|
|
1957
|
+
params = open_api_models.Params(
|
|
1958
|
+
action='ResetSnapshot',
|
|
1959
|
+
version='2020-10-02',
|
|
1960
|
+
protocol='HTTPS',
|
|
1961
|
+
pathname='/',
|
|
1962
|
+
method='POST',
|
|
1963
|
+
auth_type='Anonymous',
|
|
1964
|
+
style='RPC',
|
|
1965
|
+
req_body_type='formData',
|
|
1966
|
+
body_type='json'
|
|
1967
|
+
)
|
|
1968
|
+
return TeaCore.from_map(
|
|
1969
|
+
ecd_20201002_models.ResetSnapshotResponse(),
|
|
1970
|
+
self.call_api(params, req, runtime)
|
|
1971
|
+
)
|
|
1972
|
+
|
|
1973
|
+
async def reset_snapshot_with_options_async(
|
|
1974
|
+
self,
|
|
1975
|
+
request: ecd_20201002_models.ResetSnapshotRequest,
|
|
1976
|
+
runtime: util_models.RuntimeOptions,
|
|
1977
|
+
) -> ecd_20201002_models.ResetSnapshotResponse:
|
|
1978
|
+
UtilClient.validate_model(request)
|
|
1979
|
+
query = {}
|
|
1980
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1981
|
+
query['ClientId'] = request.client_id
|
|
1982
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1983
|
+
query['LoginToken'] = request.login_token
|
|
1984
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1985
|
+
query['RegionId'] = request.region_id
|
|
1986
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1987
|
+
query['SessionId'] = request.session_id
|
|
1988
|
+
if not UtilClient.is_unset(request.snapshot_id):
|
|
1989
|
+
query['SnapshotId'] = request.snapshot_id
|
|
1990
|
+
req = open_api_models.OpenApiRequest(
|
|
1991
|
+
query=OpenApiUtilClient.query(query)
|
|
1992
|
+
)
|
|
1993
|
+
params = open_api_models.Params(
|
|
1994
|
+
action='ResetSnapshot',
|
|
1995
|
+
version='2020-10-02',
|
|
1996
|
+
protocol='HTTPS',
|
|
1997
|
+
pathname='/',
|
|
1998
|
+
method='POST',
|
|
1999
|
+
auth_type='Anonymous',
|
|
2000
|
+
style='RPC',
|
|
2001
|
+
req_body_type='formData',
|
|
2002
|
+
body_type='json'
|
|
2003
|
+
)
|
|
2004
|
+
return TeaCore.from_map(
|
|
2005
|
+
ecd_20201002_models.ResetSnapshotResponse(),
|
|
2006
|
+
await self.call_api_async(params, req, runtime)
|
|
2007
|
+
)
|
|
2008
|
+
|
|
2009
|
+
def reset_snapshot(
|
|
2010
|
+
self,
|
|
2011
|
+
request: ecd_20201002_models.ResetSnapshotRequest,
|
|
2012
|
+
) -> ecd_20201002_models.ResetSnapshotResponse:
|
|
2013
|
+
runtime = util_models.RuntimeOptions()
|
|
2014
|
+
return self.reset_snapshot_with_options(request, runtime)
|
|
2015
|
+
|
|
2016
|
+
async def reset_snapshot_async(
|
|
2017
|
+
self,
|
|
2018
|
+
request: ecd_20201002_models.ResetSnapshotRequest,
|
|
2019
|
+
) -> ecd_20201002_models.ResetSnapshotResponse:
|
|
2020
|
+
runtime = util_models.RuntimeOptions()
|
|
2021
|
+
return await self.reset_snapshot_with_options_async(request, runtime)
|
|
2022
|
+
|
|
2023
|
+
def send_token_code_with_options(
|
|
2024
|
+
self,
|
|
2025
|
+
request: ecd_20201002_models.SendTokenCodeRequest,
|
|
2026
|
+
runtime: util_models.RuntimeOptions,
|
|
2027
|
+
) -> ecd_20201002_models.SendTokenCodeResponse:
|
|
2028
|
+
UtilClient.validate_model(request)
|
|
2029
|
+
query = {}
|
|
2030
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2031
|
+
query['ClientId'] = request.client_id
|
|
2032
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2033
|
+
query['ClientOS'] = request.client_os
|
|
2034
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2035
|
+
query['ClientVersion'] = request.client_version
|
|
2036
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
2037
|
+
query['EndUserId'] = request.end_user_id
|
|
2038
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2039
|
+
query['LoginToken'] = request.login_token
|
|
2040
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
2041
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
2042
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2043
|
+
query['SessionId'] = request.session_id
|
|
2044
|
+
if not UtilClient.is_unset(request.token_code):
|
|
2045
|
+
query['TokenCode'] = request.token_code
|
|
2046
|
+
req = open_api_models.OpenApiRequest(
|
|
2047
|
+
query=OpenApiUtilClient.query(query)
|
|
2048
|
+
)
|
|
2049
|
+
params = open_api_models.Params(
|
|
2050
|
+
action='SendTokenCode',
|
|
2051
|
+
version='2020-10-02',
|
|
2052
|
+
protocol='HTTPS',
|
|
2053
|
+
pathname='/',
|
|
2054
|
+
method='POST',
|
|
2055
|
+
auth_type='Anonymous',
|
|
2056
|
+
style='RPC',
|
|
2057
|
+
req_body_type='formData',
|
|
2058
|
+
body_type='json'
|
|
2059
|
+
)
|
|
2060
|
+
return TeaCore.from_map(
|
|
2061
|
+
ecd_20201002_models.SendTokenCodeResponse(),
|
|
2062
|
+
self.call_api(params, req, runtime)
|
|
2063
|
+
)
|
|
2064
|
+
|
|
2065
|
+
async def send_token_code_with_options_async(
|
|
2066
|
+
self,
|
|
2067
|
+
request: ecd_20201002_models.SendTokenCodeRequest,
|
|
2068
|
+
runtime: util_models.RuntimeOptions,
|
|
2069
|
+
) -> ecd_20201002_models.SendTokenCodeResponse:
|
|
2070
|
+
UtilClient.validate_model(request)
|
|
2071
|
+
query = {}
|
|
2072
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2073
|
+
query['ClientId'] = request.client_id
|
|
2074
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2075
|
+
query['ClientOS'] = request.client_os
|
|
2076
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2077
|
+
query['ClientVersion'] = request.client_version
|
|
2078
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
2079
|
+
query['EndUserId'] = request.end_user_id
|
|
2080
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2081
|
+
query['LoginToken'] = request.login_token
|
|
2082
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
2083
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
2084
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2085
|
+
query['SessionId'] = request.session_id
|
|
2086
|
+
if not UtilClient.is_unset(request.token_code):
|
|
2087
|
+
query['TokenCode'] = request.token_code
|
|
2088
|
+
req = open_api_models.OpenApiRequest(
|
|
2089
|
+
query=OpenApiUtilClient.query(query)
|
|
2090
|
+
)
|
|
2091
|
+
params = open_api_models.Params(
|
|
2092
|
+
action='SendTokenCode',
|
|
2093
|
+
version='2020-10-02',
|
|
2094
|
+
protocol='HTTPS',
|
|
2095
|
+
pathname='/',
|
|
2096
|
+
method='POST',
|
|
2097
|
+
auth_type='Anonymous',
|
|
2098
|
+
style='RPC',
|
|
2099
|
+
req_body_type='formData',
|
|
2100
|
+
body_type='json'
|
|
2101
|
+
)
|
|
2102
|
+
return TeaCore.from_map(
|
|
2103
|
+
ecd_20201002_models.SendTokenCodeResponse(),
|
|
2104
|
+
await self.call_api_async(params, req, runtime)
|
|
2105
|
+
)
|
|
2106
|
+
|
|
2107
|
+
def send_token_code(
|
|
2108
|
+
self,
|
|
2109
|
+
request: ecd_20201002_models.SendTokenCodeRequest,
|
|
2110
|
+
) -> ecd_20201002_models.SendTokenCodeResponse:
|
|
2111
|
+
runtime = util_models.RuntimeOptions()
|
|
2112
|
+
return self.send_token_code_with_options(request, runtime)
|
|
2113
|
+
|
|
2114
|
+
async def send_token_code_async(
|
|
2115
|
+
self,
|
|
2116
|
+
request: ecd_20201002_models.SendTokenCodeRequest,
|
|
2117
|
+
) -> ecd_20201002_models.SendTokenCodeResponse:
|
|
2118
|
+
runtime = util_models.RuntimeOptions()
|
|
2119
|
+
return await self.send_token_code_with_options_async(request, runtime)
|
|
2120
|
+
|
|
2121
|
+
def set_finger_print_template_with_options(
|
|
2122
|
+
self,
|
|
2123
|
+
request: ecd_20201002_models.SetFingerPrintTemplateRequest,
|
|
2124
|
+
runtime: util_models.RuntimeOptions,
|
|
2125
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateResponse:
|
|
2126
|
+
UtilClient.validate_model(request)
|
|
2127
|
+
query = {}
|
|
2128
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2129
|
+
query['ClientId'] = request.client_id
|
|
2130
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2131
|
+
query['ClientToken'] = request.client_token
|
|
2132
|
+
if not UtilClient.is_unset(request.description):
|
|
2133
|
+
query['Description'] = request.description
|
|
2134
|
+
if not UtilClient.is_unset(request.encrypted_finger_print_template):
|
|
2135
|
+
query['EncryptedFingerPrintTemplate'] = request.encrypted_finger_print_template
|
|
2136
|
+
if not UtilClient.is_unset(request.encrypted_key):
|
|
2137
|
+
query['EncryptedKey'] = request.encrypted_key
|
|
2138
|
+
if not UtilClient.is_unset(request.finger_print_template):
|
|
2139
|
+
query['FingerPrintTemplate'] = request.finger_print_template
|
|
2140
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2141
|
+
query['LoginToken'] = request.login_token
|
|
2142
|
+
if not UtilClient.is_unset(request.password):
|
|
2143
|
+
query['Password'] = request.password
|
|
2144
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2145
|
+
query['RegionId'] = request.region_id
|
|
2146
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2147
|
+
query['SessionId'] = request.session_id
|
|
2148
|
+
req = open_api_models.OpenApiRequest(
|
|
2149
|
+
query=OpenApiUtilClient.query(query)
|
|
2150
|
+
)
|
|
2151
|
+
params = open_api_models.Params(
|
|
2152
|
+
action='SetFingerPrintTemplate',
|
|
2153
|
+
version='2020-10-02',
|
|
2154
|
+
protocol='HTTPS',
|
|
2155
|
+
pathname='/',
|
|
2156
|
+
method='POST',
|
|
2157
|
+
auth_type='Anonymous',
|
|
2158
|
+
style='RPC',
|
|
2159
|
+
req_body_type='formData',
|
|
2160
|
+
body_type='json'
|
|
2161
|
+
)
|
|
2162
|
+
return TeaCore.from_map(
|
|
2163
|
+
ecd_20201002_models.SetFingerPrintTemplateResponse(),
|
|
2164
|
+
self.call_api(params, req, runtime)
|
|
2165
|
+
)
|
|
2166
|
+
|
|
2167
|
+
async def set_finger_print_template_with_options_async(
|
|
2168
|
+
self,
|
|
2169
|
+
request: ecd_20201002_models.SetFingerPrintTemplateRequest,
|
|
2170
|
+
runtime: util_models.RuntimeOptions,
|
|
2171
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateResponse:
|
|
2172
|
+
UtilClient.validate_model(request)
|
|
2173
|
+
query = {}
|
|
2174
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2175
|
+
query['ClientId'] = request.client_id
|
|
2176
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2177
|
+
query['ClientToken'] = request.client_token
|
|
2178
|
+
if not UtilClient.is_unset(request.description):
|
|
2179
|
+
query['Description'] = request.description
|
|
2180
|
+
if not UtilClient.is_unset(request.encrypted_finger_print_template):
|
|
2181
|
+
query['EncryptedFingerPrintTemplate'] = request.encrypted_finger_print_template
|
|
2182
|
+
if not UtilClient.is_unset(request.encrypted_key):
|
|
2183
|
+
query['EncryptedKey'] = request.encrypted_key
|
|
2184
|
+
if not UtilClient.is_unset(request.finger_print_template):
|
|
2185
|
+
query['FingerPrintTemplate'] = request.finger_print_template
|
|
2186
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2187
|
+
query['LoginToken'] = request.login_token
|
|
2188
|
+
if not UtilClient.is_unset(request.password):
|
|
2189
|
+
query['Password'] = request.password
|
|
2190
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2191
|
+
query['RegionId'] = request.region_id
|
|
2192
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2193
|
+
query['SessionId'] = request.session_id
|
|
2194
|
+
req = open_api_models.OpenApiRequest(
|
|
2195
|
+
query=OpenApiUtilClient.query(query)
|
|
2196
|
+
)
|
|
2197
|
+
params = open_api_models.Params(
|
|
2198
|
+
action='SetFingerPrintTemplate',
|
|
2199
|
+
version='2020-10-02',
|
|
2200
|
+
protocol='HTTPS',
|
|
2201
|
+
pathname='/',
|
|
2202
|
+
method='POST',
|
|
2203
|
+
auth_type='Anonymous',
|
|
2204
|
+
style='RPC',
|
|
2205
|
+
req_body_type='formData',
|
|
2206
|
+
body_type='json'
|
|
2207
|
+
)
|
|
2208
|
+
return TeaCore.from_map(
|
|
2209
|
+
ecd_20201002_models.SetFingerPrintTemplateResponse(),
|
|
2210
|
+
await self.call_api_async(params, req, runtime)
|
|
2211
|
+
)
|
|
2212
|
+
|
|
2213
|
+
def set_finger_print_template(
|
|
2214
|
+
self,
|
|
2215
|
+
request: ecd_20201002_models.SetFingerPrintTemplateRequest,
|
|
2216
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateResponse:
|
|
2217
|
+
runtime = util_models.RuntimeOptions()
|
|
2218
|
+
return self.set_finger_print_template_with_options(request, runtime)
|
|
2219
|
+
|
|
2220
|
+
async def set_finger_print_template_async(
|
|
2221
|
+
self,
|
|
2222
|
+
request: ecd_20201002_models.SetFingerPrintTemplateRequest,
|
|
2223
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateResponse:
|
|
2224
|
+
runtime = util_models.RuntimeOptions()
|
|
2225
|
+
return await self.set_finger_print_template_with_options_async(request, runtime)
|
|
2226
|
+
|
|
2227
|
+
def set_finger_print_template_description_with_options(
|
|
2228
|
+
self,
|
|
2229
|
+
request: ecd_20201002_models.SetFingerPrintTemplateDescriptionRequest,
|
|
2230
|
+
runtime: util_models.RuntimeOptions,
|
|
2231
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse:
|
|
2232
|
+
UtilClient.validate_model(request)
|
|
2233
|
+
query = {}
|
|
2234
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2235
|
+
query['ClientId'] = request.client_id
|
|
2236
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2237
|
+
query['ClientToken'] = request.client_token
|
|
2238
|
+
if not UtilClient.is_unset(request.description):
|
|
2239
|
+
query['Description'] = request.description
|
|
2240
|
+
if not UtilClient.is_unset(request.index):
|
|
2241
|
+
query['Index'] = request.index
|
|
2242
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2243
|
+
query['LoginToken'] = request.login_token
|
|
2244
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2245
|
+
query['RegionId'] = request.region_id
|
|
2246
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2247
|
+
query['SessionId'] = request.session_id
|
|
2248
|
+
req = open_api_models.OpenApiRequest(
|
|
2249
|
+
query=OpenApiUtilClient.query(query)
|
|
2250
|
+
)
|
|
2251
|
+
params = open_api_models.Params(
|
|
2252
|
+
action='SetFingerPrintTemplateDescription',
|
|
2253
|
+
version='2020-10-02',
|
|
2254
|
+
protocol='HTTPS',
|
|
2255
|
+
pathname='/',
|
|
2256
|
+
method='POST',
|
|
2257
|
+
auth_type='Anonymous',
|
|
2258
|
+
style='RPC',
|
|
2259
|
+
req_body_type='formData',
|
|
2260
|
+
body_type='json'
|
|
2261
|
+
)
|
|
2262
|
+
return TeaCore.from_map(
|
|
2263
|
+
ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse(),
|
|
2264
|
+
self.call_api(params, req, runtime)
|
|
2265
|
+
)
|
|
2266
|
+
|
|
2267
|
+
async def set_finger_print_template_description_with_options_async(
|
|
2268
|
+
self,
|
|
2269
|
+
request: ecd_20201002_models.SetFingerPrintTemplateDescriptionRequest,
|
|
2270
|
+
runtime: util_models.RuntimeOptions,
|
|
2271
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse:
|
|
2272
|
+
UtilClient.validate_model(request)
|
|
2273
|
+
query = {}
|
|
2274
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2275
|
+
query['ClientId'] = request.client_id
|
|
2276
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2277
|
+
query['ClientToken'] = request.client_token
|
|
2278
|
+
if not UtilClient.is_unset(request.description):
|
|
2279
|
+
query['Description'] = request.description
|
|
2280
|
+
if not UtilClient.is_unset(request.index):
|
|
2281
|
+
query['Index'] = request.index
|
|
2282
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2283
|
+
query['LoginToken'] = request.login_token
|
|
2284
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2285
|
+
query['RegionId'] = request.region_id
|
|
2286
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2287
|
+
query['SessionId'] = request.session_id
|
|
2288
|
+
req = open_api_models.OpenApiRequest(
|
|
2289
|
+
query=OpenApiUtilClient.query(query)
|
|
2290
|
+
)
|
|
2291
|
+
params = open_api_models.Params(
|
|
2292
|
+
action='SetFingerPrintTemplateDescription',
|
|
2293
|
+
version='2020-10-02',
|
|
2294
|
+
protocol='HTTPS',
|
|
2295
|
+
pathname='/',
|
|
2296
|
+
method='POST',
|
|
2297
|
+
auth_type='Anonymous',
|
|
2298
|
+
style='RPC',
|
|
2299
|
+
req_body_type='formData',
|
|
2300
|
+
body_type='json'
|
|
2301
|
+
)
|
|
2302
|
+
return TeaCore.from_map(
|
|
2303
|
+
ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse(),
|
|
2304
|
+
await self.call_api_async(params, req, runtime)
|
|
2305
|
+
)
|
|
2306
|
+
|
|
2307
|
+
def set_finger_print_template_description(
|
|
2308
|
+
self,
|
|
2309
|
+
request: ecd_20201002_models.SetFingerPrintTemplateDescriptionRequest,
|
|
2310
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse:
|
|
2311
|
+
runtime = util_models.RuntimeOptions()
|
|
2312
|
+
return self.set_finger_print_template_description_with_options(request, runtime)
|
|
2313
|
+
|
|
2314
|
+
async def set_finger_print_template_description_async(
|
|
2315
|
+
self,
|
|
2316
|
+
request: ecd_20201002_models.SetFingerPrintTemplateDescriptionRequest,
|
|
2317
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse:
|
|
2318
|
+
runtime = util_models.RuntimeOptions()
|
|
2319
|
+
return await self.set_finger_print_template_description_with_options_async(request, runtime)
|
|
2320
|
+
|
|
2321
|
+
def start_desktops_with_options(
|
|
2322
|
+
self,
|
|
2323
|
+
request: ecd_20201002_models.StartDesktopsRequest,
|
|
2324
|
+
runtime: util_models.RuntimeOptions,
|
|
2325
|
+
) -> ecd_20201002_models.StartDesktopsResponse:
|
|
2326
|
+
"""
|
|
2327
|
+
The ID of the client.
|
|
2328
|
+
|
|
2329
|
+
@param request: StartDesktopsRequest
|
|
2330
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2331
|
+
@return: StartDesktopsResponse
|
|
2332
|
+
"""
|
|
2333
|
+
UtilClient.validate_model(request)
|
|
2334
|
+
query = {}
|
|
2335
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2336
|
+
query['ClientId'] = request.client_id
|
|
2337
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2338
|
+
query['ClientOS'] = request.client_os
|
|
2339
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2340
|
+
query['ClientToken'] = request.client_token
|
|
2341
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2342
|
+
query['ClientVersion'] = request.client_version
|
|
2343
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2344
|
+
query['DesktopId'] = request.desktop_id
|
|
2345
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2346
|
+
query['LoginToken'] = request.login_token
|
|
2347
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2348
|
+
query['RegionId'] = request.region_id
|
|
2349
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2350
|
+
query['SessionId'] = request.session_id
|
|
2351
|
+
req = open_api_models.OpenApiRequest(
|
|
2352
|
+
query=OpenApiUtilClient.query(query)
|
|
2353
|
+
)
|
|
2354
|
+
params = open_api_models.Params(
|
|
2355
|
+
action='StartDesktops',
|
|
2356
|
+
version='2020-10-02',
|
|
2357
|
+
protocol='HTTPS',
|
|
2358
|
+
pathname='/',
|
|
2359
|
+
method='POST',
|
|
2360
|
+
auth_type='Anonymous',
|
|
2361
|
+
style='RPC',
|
|
2362
|
+
req_body_type='formData',
|
|
2363
|
+
body_type='json'
|
|
2364
|
+
)
|
|
2365
|
+
return TeaCore.from_map(
|
|
2366
|
+
ecd_20201002_models.StartDesktopsResponse(),
|
|
2367
|
+
self.call_api(params, req, runtime)
|
|
2368
|
+
)
|
|
2369
|
+
|
|
2370
|
+
async def start_desktops_with_options_async(
|
|
2371
|
+
self,
|
|
2372
|
+
request: ecd_20201002_models.StartDesktopsRequest,
|
|
2373
|
+
runtime: util_models.RuntimeOptions,
|
|
2374
|
+
) -> ecd_20201002_models.StartDesktopsResponse:
|
|
2375
|
+
"""
|
|
2376
|
+
The ID of the client.
|
|
2377
|
+
|
|
2378
|
+
@param request: StartDesktopsRequest
|
|
2379
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2380
|
+
@return: StartDesktopsResponse
|
|
2381
|
+
"""
|
|
2382
|
+
UtilClient.validate_model(request)
|
|
2383
|
+
query = {}
|
|
2384
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2385
|
+
query['ClientId'] = request.client_id
|
|
2386
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2387
|
+
query['ClientOS'] = request.client_os
|
|
2388
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2389
|
+
query['ClientToken'] = request.client_token
|
|
2390
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2391
|
+
query['ClientVersion'] = request.client_version
|
|
2392
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2393
|
+
query['DesktopId'] = request.desktop_id
|
|
2394
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2395
|
+
query['LoginToken'] = request.login_token
|
|
2396
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2397
|
+
query['RegionId'] = request.region_id
|
|
2398
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2399
|
+
query['SessionId'] = request.session_id
|
|
2400
|
+
req = open_api_models.OpenApiRequest(
|
|
2401
|
+
query=OpenApiUtilClient.query(query)
|
|
2402
|
+
)
|
|
2403
|
+
params = open_api_models.Params(
|
|
2404
|
+
action='StartDesktops',
|
|
2405
|
+
version='2020-10-02',
|
|
2406
|
+
protocol='HTTPS',
|
|
2407
|
+
pathname='/',
|
|
2408
|
+
method='POST',
|
|
2409
|
+
auth_type='Anonymous',
|
|
2410
|
+
style='RPC',
|
|
2411
|
+
req_body_type='formData',
|
|
2412
|
+
body_type='json'
|
|
2413
|
+
)
|
|
2414
|
+
return TeaCore.from_map(
|
|
2415
|
+
ecd_20201002_models.StartDesktopsResponse(),
|
|
2416
|
+
await self.call_api_async(params, req, runtime)
|
|
2417
|
+
)
|
|
2418
|
+
|
|
2419
|
+
def start_desktops(
|
|
2420
|
+
self,
|
|
2421
|
+
request: ecd_20201002_models.StartDesktopsRequest,
|
|
2422
|
+
) -> ecd_20201002_models.StartDesktopsResponse:
|
|
2423
|
+
"""
|
|
2424
|
+
The ID of the client.
|
|
2425
|
+
|
|
2426
|
+
@param request: StartDesktopsRequest
|
|
2427
|
+
@return: StartDesktopsResponse
|
|
2428
|
+
"""
|
|
2429
|
+
runtime = util_models.RuntimeOptions()
|
|
2430
|
+
return self.start_desktops_with_options(request, runtime)
|
|
2431
|
+
|
|
2432
|
+
async def start_desktops_async(
|
|
2433
|
+
self,
|
|
2434
|
+
request: ecd_20201002_models.StartDesktopsRequest,
|
|
2435
|
+
) -> ecd_20201002_models.StartDesktopsResponse:
|
|
2436
|
+
"""
|
|
2437
|
+
The ID of the client.
|
|
2438
|
+
|
|
2439
|
+
@param request: StartDesktopsRequest
|
|
2440
|
+
@return: StartDesktopsResponse
|
|
2441
|
+
"""
|
|
2442
|
+
runtime = util_models.RuntimeOptions()
|
|
2443
|
+
return await self.start_desktops_with_options_async(request, runtime)
|
|
2444
|
+
|
|
2445
|
+
def start_record_content_with_options(
|
|
2446
|
+
self,
|
|
2447
|
+
request: ecd_20201002_models.StartRecordContentRequest,
|
|
2448
|
+
runtime: util_models.RuntimeOptions,
|
|
2449
|
+
) -> ecd_20201002_models.StartRecordContentResponse:
|
|
2450
|
+
UtilClient.validate_model(request)
|
|
2451
|
+
query = {}
|
|
2452
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2453
|
+
query['ClientId'] = request.client_id
|
|
2454
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2455
|
+
query['ClientOS'] = request.client_os
|
|
2456
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2457
|
+
query['ClientVersion'] = request.client_version
|
|
2458
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2459
|
+
query['DesktopId'] = request.desktop_id
|
|
2460
|
+
if not UtilClient.is_unset(request.file_path):
|
|
2461
|
+
query['FilePath'] = request.file_path
|
|
2462
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2463
|
+
query['LoginToken'] = request.login_token
|
|
2464
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2465
|
+
query['RegionId'] = request.region_id
|
|
2466
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2467
|
+
query['SessionId'] = request.session_id
|
|
2468
|
+
req = open_api_models.OpenApiRequest(
|
|
2469
|
+
query=OpenApiUtilClient.query(query)
|
|
2470
|
+
)
|
|
2471
|
+
params = open_api_models.Params(
|
|
2472
|
+
action='StartRecordContent',
|
|
2473
|
+
version='2020-10-02',
|
|
2474
|
+
protocol='HTTPS',
|
|
2475
|
+
pathname='/',
|
|
2476
|
+
method='POST',
|
|
2477
|
+
auth_type='Anonymous',
|
|
2478
|
+
style='RPC',
|
|
2479
|
+
req_body_type='formData',
|
|
2480
|
+
body_type='json'
|
|
2481
|
+
)
|
|
2482
|
+
return TeaCore.from_map(
|
|
2483
|
+
ecd_20201002_models.StartRecordContentResponse(),
|
|
2484
|
+
self.call_api(params, req, runtime)
|
|
2485
|
+
)
|
|
2486
|
+
|
|
2487
|
+
async def start_record_content_with_options_async(
|
|
2488
|
+
self,
|
|
2489
|
+
request: ecd_20201002_models.StartRecordContentRequest,
|
|
2490
|
+
runtime: util_models.RuntimeOptions,
|
|
2491
|
+
) -> ecd_20201002_models.StartRecordContentResponse:
|
|
2492
|
+
UtilClient.validate_model(request)
|
|
2493
|
+
query = {}
|
|
2494
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2495
|
+
query['ClientId'] = request.client_id
|
|
2496
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2497
|
+
query['ClientOS'] = request.client_os
|
|
2498
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2499
|
+
query['ClientVersion'] = request.client_version
|
|
2500
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2501
|
+
query['DesktopId'] = request.desktop_id
|
|
2502
|
+
if not UtilClient.is_unset(request.file_path):
|
|
2503
|
+
query['FilePath'] = request.file_path
|
|
2504
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2505
|
+
query['LoginToken'] = request.login_token
|
|
2506
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2507
|
+
query['RegionId'] = request.region_id
|
|
2508
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2509
|
+
query['SessionId'] = request.session_id
|
|
2510
|
+
req = open_api_models.OpenApiRequest(
|
|
2511
|
+
query=OpenApiUtilClient.query(query)
|
|
2512
|
+
)
|
|
2513
|
+
params = open_api_models.Params(
|
|
2514
|
+
action='StartRecordContent',
|
|
2515
|
+
version='2020-10-02',
|
|
2516
|
+
protocol='HTTPS',
|
|
2517
|
+
pathname='/',
|
|
2518
|
+
method='POST',
|
|
2519
|
+
auth_type='Anonymous',
|
|
2520
|
+
style='RPC',
|
|
2521
|
+
req_body_type='formData',
|
|
2522
|
+
body_type='json'
|
|
2523
|
+
)
|
|
2524
|
+
return TeaCore.from_map(
|
|
2525
|
+
ecd_20201002_models.StartRecordContentResponse(),
|
|
2526
|
+
await self.call_api_async(params, req, runtime)
|
|
2527
|
+
)
|
|
2528
|
+
|
|
2529
|
+
def start_record_content(
|
|
2530
|
+
self,
|
|
2531
|
+
request: ecd_20201002_models.StartRecordContentRequest,
|
|
2532
|
+
) -> ecd_20201002_models.StartRecordContentResponse:
|
|
2533
|
+
runtime = util_models.RuntimeOptions()
|
|
2534
|
+
return self.start_record_content_with_options(request, runtime)
|
|
2535
|
+
|
|
2536
|
+
async def start_record_content_async(
|
|
2537
|
+
self,
|
|
2538
|
+
request: ecd_20201002_models.StartRecordContentRequest,
|
|
2539
|
+
) -> ecd_20201002_models.StartRecordContentResponse:
|
|
2540
|
+
runtime = util_models.RuntimeOptions()
|
|
2541
|
+
return await self.start_record_content_with_options_async(request, runtime)
|
|
2542
|
+
|
|
2543
|
+
def stop_desktops_with_options(
|
|
2544
|
+
self,
|
|
2545
|
+
request: ecd_20201002_models.StopDesktopsRequest,
|
|
2546
|
+
runtime: util_models.RuntimeOptions,
|
|
2547
|
+
) -> ecd_20201002_models.StopDesktopsResponse:
|
|
2548
|
+
"""
|
|
2549
|
+
The cloud desktops that you want to stop by calling this operation must be in the Running state. If the call is successful, the cloud desktops enter the Stopped state.
|
|
2550
|
+
|
|
2551
|
+
@param request: StopDesktopsRequest
|
|
2552
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2553
|
+
@return: StopDesktopsResponse
|
|
2554
|
+
"""
|
|
2555
|
+
UtilClient.validate_model(request)
|
|
2556
|
+
query = {}
|
|
2557
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2558
|
+
query['ClientId'] = request.client_id
|
|
2559
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2560
|
+
query['ClientOS'] = request.client_os
|
|
2561
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2562
|
+
query['ClientToken'] = request.client_token
|
|
2563
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2564
|
+
query['ClientVersion'] = request.client_version
|
|
2565
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2566
|
+
query['DesktopId'] = request.desktop_id
|
|
2567
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2568
|
+
query['LoginToken'] = request.login_token
|
|
2569
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2570
|
+
query['RegionId'] = request.region_id
|
|
2571
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2572
|
+
query['SessionId'] = request.session_id
|
|
2573
|
+
if not UtilClient.is_unset(request.session_token):
|
|
2574
|
+
query['SessionToken'] = request.session_token
|
|
2575
|
+
req = open_api_models.OpenApiRequest(
|
|
2576
|
+
query=OpenApiUtilClient.query(query)
|
|
2577
|
+
)
|
|
2578
|
+
params = open_api_models.Params(
|
|
2579
|
+
action='StopDesktops',
|
|
2580
|
+
version='2020-10-02',
|
|
2581
|
+
protocol='HTTPS',
|
|
2582
|
+
pathname='/',
|
|
2583
|
+
method='POST',
|
|
2584
|
+
auth_type='Anonymous',
|
|
2585
|
+
style='RPC',
|
|
2586
|
+
req_body_type='formData',
|
|
2587
|
+
body_type='json'
|
|
2588
|
+
)
|
|
2589
|
+
return TeaCore.from_map(
|
|
2590
|
+
ecd_20201002_models.StopDesktopsResponse(),
|
|
2591
|
+
self.call_api(params, req, runtime)
|
|
2592
|
+
)
|
|
2593
|
+
|
|
2594
|
+
async def stop_desktops_with_options_async(
|
|
2595
|
+
self,
|
|
2596
|
+
request: ecd_20201002_models.StopDesktopsRequest,
|
|
2597
|
+
runtime: util_models.RuntimeOptions,
|
|
2598
|
+
) -> ecd_20201002_models.StopDesktopsResponse:
|
|
2599
|
+
"""
|
|
2600
|
+
The cloud desktops that you want to stop by calling this operation must be in the Running state. If the call is successful, the cloud desktops enter the Stopped state.
|
|
2601
|
+
|
|
2602
|
+
@param request: StopDesktopsRequest
|
|
2603
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2604
|
+
@return: StopDesktopsResponse
|
|
2605
|
+
"""
|
|
2606
|
+
UtilClient.validate_model(request)
|
|
2607
|
+
query = {}
|
|
2608
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2609
|
+
query['ClientId'] = request.client_id
|
|
2610
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2611
|
+
query['ClientOS'] = request.client_os
|
|
2612
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2613
|
+
query['ClientToken'] = request.client_token
|
|
2614
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2615
|
+
query['ClientVersion'] = request.client_version
|
|
2616
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2617
|
+
query['DesktopId'] = request.desktop_id
|
|
2618
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2619
|
+
query['LoginToken'] = request.login_token
|
|
2620
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2621
|
+
query['RegionId'] = request.region_id
|
|
2622
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2623
|
+
query['SessionId'] = request.session_id
|
|
2624
|
+
if not UtilClient.is_unset(request.session_token):
|
|
2625
|
+
query['SessionToken'] = request.session_token
|
|
2626
|
+
req = open_api_models.OpenApiRequest(
|
|
2627
|
+
query=OpenApiUtilClient.query(query)
|
|
2628
|
+
)
|
|
2629
|
+
params = open_api_models.Params(
|
|
2630
|
+
action='StopDesktops',
|
|
2631
|
+
version='2020-10-02',
|
|
2632
|
+
protocol='HTTPS',
|
|
2633
|
+
pathname='/',
|
|
2634
|
+
method='POST',
|
|
2635
|
+
auth_type='Anonymous',
|
|
2636
|
+
style='RPC',
|
|
2637
|
+
req_body_type='formData',
|
|
2638
|
+
body_type='json'
|
|
2639
|
+
)
|
|
2640
|
+
return TeaCore.from_map(
|
|
2641
|
+
ecd_20201002_models.StopDesktopsResponse(),
|
|
2642
|
+
await self.call_api_async(params, req, runtime)
|
|
2643
|
+
)
|
|
2644
|
+
|
|
2645
|
+
def stop_desktops(
|
|
2646
|
+
self,
|
|
2647
|
+
request: ecd_20201002_models.StopDesktopsRequest,
|
|
2648
|
+
) -> ecd_20201002_models.StopDesktopsResponse:
|
|
2649
|
+
"""
|
|
2650
|
+
The cloud desktops that you want to stop by calling this operation must be in the Running state. If the call is successful, the cloud desktops enter the Stopped state.
|
|
2651
|
+
|
|
2652
|
+
@param request: StopDesktopsRequest
|
|
2653
|
+
@return: StopDesktopsResponse
|
|
2654
|
+
"""
|
|
2655
|
+
runtime = util_models.RuntimeOptions()
|
|
2656
|
+
return self.stop_desktops_with_options(request, runtime)
|
|
2657
|
+
|
|
2658
|
+
async def stop_desktops_async(
|
|
2659
|
+
self,
|
|
2660
|
+
request: ecd_20201002_models.StopDesktopsRequest,
|
|
2661
|
+
) -> ecd_20201002_models.StopDesktopsResponse:
|
|
2662
|
+
"""
|
|
2663
|
+
The cloud desktops that you want to stop by calling this operation must be in the Running state. If the call is successful, the cloud desktops enter the Stopped state.
|
|
2664
|
+
|
|
2665
|
+
@param request: StopDesktopsRequest
|
|
2666
|
+
@return: StopDesktopsResponse
|
|
2667
|
+
"""
|
|
2668
|
+
runtime = util_models.RuntimeOptions()
|
|
2669
|
+
return await self.stop_desktops_with_options_async(request, runtime)
|
|
2670
|
+
|
|
2671
|
+
def stop_record_content_with_options(
|
|
2672
|
+
self,
|
|
2673
|
+
request: ecd_20201002_models.StopRecordContentRequest,
|
|
2674
|
+
runtime: util_models.RuntimeOptions,
|
|
2675
|
+
) -> ecd_20201002_models.StopRecordContentResponse:
|
|
2676
|
+
UtilClient.validate_model(request)
|
|
2677
|
+
query = {}
|
|
2678
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2679
|
+
query['ClientId'] = request.client_id
|
|
2680
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2681
|
+
query['ClientOS'] = request.client_os
|
|
2682
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2683
|
+
query['ClientVersion'] = request.client_version
|
|
2684
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2685
|
+
query['DesktopId'] = request.desktop_id
|
|
2686
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2687
|
+
query['LoginToken'] = request.login_token
|
|
2688
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2689
|
+
query['RegionId'] = request.region_id
|
|
2690
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2691
|
+
query['SessionId'] = request.session_id
|
|
2692
|
+
req = open_api_models.OpenApiRequest(
|
|
2693
|
+
query=OpenApiUtilClient.query(query)
|
|
2694
|
+
)
|
|
2695
|
+
params = open_api_models.Params(
|
|
2696
|
+
action='StopRecordContent',
|
|
2697
|
+
version='2020-10-02',
|
|
2698
|
+
protocol='HTTPS',
|
|
2699
|
+
pathname='/',
|
|
2700
|
+
method='POST',
|
|
2701
|
+
auth_type='Anonymous',
|
|
2702
|
+
style='RPC',
|
|
2703
|
+
req_body_type='formData',
|
|
2704
|
+
body_type='json'
|
|
2705
|
+
)
|
|
2706
|
+
return TeaCore.from_map(
|
|
2707
|
+
ecd_20201002_models.StopRecordContentResponse(),
|
|
2708
|
+
self.call_api(params, req, runtime)
|
|
2709
|
+
)
|
|
2710
|
+
|
|
2711
|
+
async def stop_record_content_with_options_async(
|
|
2712
|
+
self,
|
|
2713
|
+
request: ecd_20201002_models.StopRecordContentRequest,
|
|
2714
|
+
runtime: util_models.RuntimeOptions,
|
|
2715
|
+
) -> ecd_20201002_models.StopRecordContentResponse:
|
|
2716
|
+
UtilClient.validate_model(request)
|
|
2717
|
+
query = {}
|
|
2718
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2719
|
+
query['ClientId'] = request.client_id
|
|
2720
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2721
|
+
query['ClientOS'] = request.client_os
|
|
2722
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2723
|
+
query['ClientVersion'] = request.client_version
|
|
2724
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2725
|
+
query['DesktopId'] = request.desktop_id
|
|
2726
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2727
|
+
query['LoginToken'] = request.login_token
|
|
2728
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2729
|
+
query['RegionId'] = request.region_id
|
|
2730
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2731
|
+
query['SessionId'] = request.session_id
|
|
2732
|
+
req = open_api_models.OpenApiRequest(
|
|
2733
|
+
query=OpenApiUtilClient.query(query)
|
|
2734
|
+
)
|
|
2735
|
+
params = open_api_models.Params(
|
|
2736
|
+
action='StopRecordContent',
|
|
2737
|
+
version='2020-10-02',
|
|
2738
|
+
protocol='HTTPS',
|
|
2739
|
+
pathname='/',
|
|
2740
|
+
method='POST',
|
|
2741
|
+
auth_type='Anonymous',
|
|
2742
|
+
style='RPC',
|
|
2743
|
+
req_body_type='formData',
|
|
2744
|
+
body_type='json'
|
|
2745
|
+
)
|
|
2746
|
+
return TeaCore.from_map(
|
|
2747
|
+
ecd_20201002_models.StopRecordContentResponse(),
|
|
2748
|
+
await self.call_api_async(params, req, runtime)
|
|
2749
|
+
)
|
|
2750
|
+
|
|
2751
|
+
def stop_record_content(
|
|
2752
|
+
self,
|
|
2753
|
+
request: ecd_20201002_models.StopRecordContentRequest,
|
|
2754
|
+
) -> ecd_20201002_models.StopRecordContentResponse:
|
|
2755
|
+
runtime = util_models.RuntimeOptions()
|
|
2756
|
+
return self.stop_record_content_with_options(request, runtime)
|
|
2757
|
+
|
|
2758
|
+
async def stop_record_content_async(
|
|
2759
|
+
self,
|
|
2760
|
+
request: ecd_20201002_models.StopRecordContentRequest,
|
|
2761
|
+
) -> ecd_20201002_models.StopRecordContentResponse:
|
|
2762
|
+
runtime = util_models.RuntimeOptions()
|
|
2763
|
+
return await self.stop_record_content_with_options_async(request, runtime)
|
|
2764
|
+
|
|
2765
|
+
def unbind_user_desktop_with_options(
|
|
2766
|
+
self,
|
|
2767
|
+
request: ecd_20201002_models.UnbindUserDesktopRequest,
|
|
2768
|
+
runtime: util_models.RuntimeOptions,
|
|
2769
|
+
) -> ecd_20201002_models.UnbindUserDesktopResponse:
|
|
2770
|
+
UtilClient.validate_model(request)
|
|
2771
|
+
query = {}
|
|
2772
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2773
|
+
query['ClientId'] = request.client_id
|
|
2774
|
+
if not UtilClient.is_unset(request.client_type):
|
|
2775
|
+
query['ClientType'] = request.client_type
|
|
2776
|
+
if not UtilClient.is_unset(request.force):
|
|
2777
|
+
query['Force'] = request.force
|
|
2778
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2779
|
+
query['LoginToken'] = request.login_token
|
|
2780
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2781
|
+
query['RegionId'] = request.region_id
|
|
2782
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2783
|
+
query['SessionId'] = request.session_id
|
|
2784
|
+
if not UtilClient.is_unset(request.user_desktop_id):
|
|
2785
|
+
query['UserDesktopId'] = request.user_desktop_id
|
|
2786
|
+
req = open_api_models.OpenApiRequest(
|
|
2787
|
+
query=OpenApiUtilClient.query(query)
|
|
2788
|
+
)
|
|
2789
|
+
params = open_api_models.Params(
|
|
2790
|
+
action='UnbindUserDesktop',
|
|
2791
|
+
version='2020-10-02',
|
|
2792
|
+
protocol='HTTPS',
|
|
2793
|
+
pathname='/',
|
|
2794
|
+
method='POST',
|
|
2795
|
+
auth_type='Anonymous',
|
|
2796
|
+
style='RPC',
|
|
2797
|
+
req_body_type='formData',
|
|
2798
|
+
body_type='json'
|
|
2799
|
+
)
|
|
2800
|
+
return TeaCore.from_map(
|
|
2801
|
+
ecd_20201002_models.UnbindUserDesktopResponse(),
|
|
2802
|
+
self.call_api(params, req, runtime)
|
|
2803
|
+
)
|
|
2804
|
+
|
|
2805
|
+
async def unbind_user_desktop_with_options_async(
|
|
2806
|
+
self,
|
|
2807
|
+
request: ecd_20201002_models.UnbindUserDesktopRequest,
|
|
2808
|
+
runtime: util_models.RuntimeOptions,
|
|
2809
|
+
) -> ecd_20201002_models.UnbindUserDesktopResponse:
|
|
2810
|
+
UtilClient.validate_model(request)
|
|
2811
|
+
query = {}
|
|
2812
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2813
|
+
query['ClientId'] = request.client_id
|
|
2814
|
+
if not UtilClient.is_unset(request.client_type):
|
|
2815
|
+
query['ClientType'] = request.client_type
|
|
2816
|
+
if not UtilClient.is_unset(request.force):
|
|
2817
|
+
query['Force'] = request.force
|
|
2818
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2819
|
+
query['LoginToken'] = request.login_token
|
|
2820
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2821
|
+
query['RegionId'] = request.region_id
|
|
2822
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2823
|
+
query['SessionId'] = request.session_id
|
|
2824
|
+
if not UtilClient.is_unset(request.user_desktop_id):
|
|
2825
|
+
query['UserDesktopId'] = request.user_desktop_id
|
|
2826
|
+
req = open_api_models.OpenApiRequest(
|
|
2827
|
+
query=OpenApiUtilClient.query(query)
|
|
2828
|
+
)
|
|
2829
|
+
params = open_api_models.Params(
|
|
2830
|
+
action='UnbindUserDesktop',
|
|
2831
|
+
version='2020-10-02',
|
|
2832
|
+
protocol='HTTPS',
|
|
2833
|
+
pathname='/',
|
|
2834
|
+
method='POST',
|
|
2835
|
+
auth_type='Anonymous',
|
|
2836
|
+
style='RPC',
|
|
2837
|
+
req_body_type='formData',
|
|
2838
|
+
body_type='json'
|
|
2839
|
+
)
|
|
2840
|
+
return TeaCore.from_map(
|
|
2841
|
+
ecd_20201002_models.UnbindUserDesktopResponse(),
|
|
2842
|
+
await self.call_api_async(params, req, runtime)
|
|
2843
|
+
)
|
|
2844
|
+
|
|
2845
|
+
def unbind_user_desktop(
|
|
2846
|
+
self,
|
|
2847
|
+
request: ecd_20201002_models.UnbindUserDesktopRequest,
|
|
2848
|
+
) -> ecd_20201002_models.UnbindUserDesktopResponse:
|
|
2849
|
+
runtime = util_models.RuntimeOptions()
|
|
2850
|
+
return self.unbind_user_desktop_with_options(request, runtime)
|
|
2851
|
+
|
|
2852
|
+
async def unbind_user_desktop_async(
|
|
2853
|
+
self,
|
|
2854
|
+
request: ecd_20201002_models.UnbindUserDesktopRequest,
|
|
2855
|
+
) -> ecd_20201002_models.UnbindUserDesktopResponse:
|
|
2856
|
+
runtime = util_models.RuntimeOptions()
|
|
2857
|
+
return await self.unbind_user_desktop_with_options_async(request, runtime)
|
|
2858
|
+
|
|
2859
|
+
def verify_credential_with_options(
|
|
2860
|
+
self,
|
|
2861
|
+
request: ecd_20201002_models.VerifyCredentialRequest,
|
|
2862
|
+
runtime: util_models.RuntimeOptions,
|
|
2863
|
+
) -> ecd_20201002_models.VerifyCredentialResponse:
|
|
2864
|
+
UtilClient.validate_model(request)
|
|
2865
|
+
query = {}
|
|
2866
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2867
|
+
query['ClientId'] = request.client_id
|
|
2868
|
+
if not UtilClient.is_unset(request.credential):
|
|
2869
|
+
query['Credential'] = request.credential
|
|
2870
|
+
if not UtilClient.is_unset(request.credential_type):
|
|
2871
|
+
query['CredentialType'] = request.credential_type
|
|
2872
|
+
if not UtilClient.is_unset(request.encrypted_key):
|
|
2873
|
+
query['EncryptedKey'] = request.encrypted_key
|
|
2874
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2875
|
+
query['LoginToken'] = request.login_token
|
|
2876
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
2877
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
2878
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2879
|
+
query['RegionId'] = request.region_id
|
|
2880
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2881
|
+
query['SessionId'] = request.session_id
|
|
2882
|
+
req = open_api_models.OpenApiRequest(
|
|
2883
|
+
query=OpenApiUtilClient.query(query)
|
|
2884
|
+
)
|
|
2885
|
+
params = open_api_models.Params(
|
|
2886
|
+
action='VerifyCredential',
|
|
2887
|
+
version='2020-10-02',
|
|
2888
|
+
protocol='HTTPS',
|
|
2889
|
+
pathname='/',
|
|
2890
|
+
method='POST',
|
|
2891
|
+
auth_type='Anonymous',
|
|
2892
|
+
style='RPC',
|
|
2893
|
+
req_body_type='formData',
|
|
2894
|
+
body_type='json'
|
|
2895
|
+
)
|
|
2896
|
+
return TeaCore.from_map(
|
|
2897
|
+
ecd_20201002_models.VerifyCredentialResponse(),
|
|
2898
|
+
self.call_api(params, req, runtime)
|
|
2899
|
+
)
|
|
2900
|
+
|
|
2901
|
+
async def verify_credential_with_options_async(
|
|
2902
|
+
self,
|
|
2903
|
+
request: ecd_20201002_models.VerifyCredentialRequest,
|
|
2904
|
+
runtime: util_models.RuntimeOptions,
|
|
2905
|
+
) -> ecd_20201002_models.VerifyCredentialResponse:
|
|
2906
|
+
UtilClient.validate_model(request)
|
|
2907
|
+
query = {}
|
|
2908
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2909
|
+
query['ClientId'] = request.client_id
|
|
2910
|
+
if not UtilClient.is_unset(request.credential):
|
|
2911
|
+
query['Credential'] = request.credential
|
|
2912
|
+
if not UtilClient.is_unset(request.credential_type):
|
|
2913
|
+
query['CredentialType'] = request.credential_type
|
|
2914
|
+
if not UtilClient.is_unset(request.encrypted_key):
|
|
2915
|
+
query['EncryptedKey'] = request.encrypted_key
|
|
2916
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2917
|
+
query['LoginToken'] = request.login_token
|
|
2918
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
2919
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
2920
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2921
|
+
query['RegionId'] = request.region_id
|
|
2922
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2923
|
+
query['SessionId'] = request.session_id
|
|
2924
|
+
req = open_api_models.OpenApiRequest(
|
|
2925
|
+
query=OpenApiUtilClient.query(query)
|
|
2926
|
+
)
|
|
2927
|
+
params = open_api_models.Params(
|
|
2928
|
+
action='VerifyCredential',
|
|
2929
|
+
version='2020-10-02',
|
|
2930
|
+
protocol='HTTPS',
|
|
2931
|
+
pathname='/',
|
|
2932
|
+
method='POST',
|
|
2933
|
+
auth_type='Anonymous',
|
|
2934
|
+
style='RPC',
|
|
2935
|
+
req_body_type='formData',
|
|
2936
|
+
body_type='json'
|
|
2937
|
+
)
|
|
2938
|
+
return TeaCore.from_map(
|
|
2939
|
+
ecd_20201002_models.VerifyCredentialResponse(),
|
|
2940
|
+
await self.call_api_async(params, req, runtime)
|
|
2941
|
+
)
|
|
2942
|
+
|
|
2943
|
+
def verify_credential(
|
|
2944
|
+
self,
|
|
2945
|
+
request: ecd_20201002_models.VerifyCredentialRequest,
|
|
2946
|
+
) -> ecd_20201002_models.VerifyCredentialResponse:
|
|
2947
|
+
runtime = util_models.RuntimeOptions()
|
|
2948
|
+
return self.verify_credential_with_options(request, runtime)
|
|
2949
|
+
|
|
2950
|
+
async def verify_credential_async(
|
|
2951
|
+
self,
|
|
2952
|
+
request: ecd_20201002_models.VerifyCredentialRequest,
|
|
2953
|
+
) -> ecd_20201002_models.VerifyCredentialResponse:
|
|
2954
|
+
runtime = util_models.RuntimeOptions()
|
|
2955
|
+
return await self.verify_credential_with_options_async(request, runtime)
|