alibabacloud-ecd20201002 1.1.6__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 +3579 -0
- alibabacloud_ecd20201002/models.py +5682 -0
- alibabacloud_ecd20201002-1.1.6.dist-info/LICENSE +13 -0
- alibabacloud_ecd20201002-1.1.6.dist-info/METADATA +69 -0
- alibabacloud_ecd20201002-1.1.6.dist-info/RECORD +8 -0
- alibabacloud_ecd20201002-1.1.6.dist-info/WHEEL +5 -0
- alibabacloud_ecd20201002-1.1.6.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,3579 @@
|
|
|
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
|
+
"""
|
|
51
|
+
@summary 允许桌面FOTA升级
|
|
52
|
+
|
|
53
|
+
@param request: ApproveFotaUpdateRequest
|
|
54
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
55
|
+
@return: ApproveFotaUpdateResponse
|
|
56
|
+
"""
|
|
57
|
+
UtilClient.validate_model(request)
|
|
58
|
+
query = {}
|
|
59
|
+
if not UtilClient.is_unset(request.app_version):
|
|
60
|
+
query['AppVersion'] = request.app_version
|
|
61
|
+
if not UtilClient.is_unset(request.client_id):
|
|
62
|
+
query['ClientId'] = request.client_id
|
|
63
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
64
|
+
query['DesktopId'] = request.desktop_id
|
|
65
|
+
if not UtilClient.is_unset(request.login_token):
|
|
66
|
+
query['LoginToken'] = request.login_token
|
|
67
|
+
if not UtilClient.is_unset(request.region_id):
|
|
68
|
+
query['RegionId'] = request.region_id
|
|
69
|
+
if not UtilClient.is_unset(request.session_id):
|
|
70
|
+
query['SessionId'] = request.session_id
|
|
71
|
+
if not UtilClient.is_unset(request.uuid):
|
|
72
|
+
query['Uuid'] = request.uuid
|
|
73
|
+
req = open_api_models.OpenApiRequest(
|
|
74
|
+
query=OpenApiUtilClient.query(query)
|
|
75
|
+
)
|
|
76
|
+
params = open_api_models.Params(
|
|
77
|
+
action='ApproveFotaUpdate',
|
|
78
|
+
version='2020-10-02',
|
|
79
|
+
protocol='HTTPS',
|
|
80
|
+
pathname='/',
|
|
81
|
+
method='POST',
|
|
82
|
+
auth_type='Anonymous',
|
|
83
|
+
style='RPC',
|
|
84
|
+
req_body_type='formData',
|
|
85
|
+
body_type='json'
|
|
86
|
+
)
|
|
87
|
+
return TeaCore.from_map(
|
|
88
|
+
ecd_20201002_models.ApproveFotaUpdateResponse(),
|
|
89
|
+
self.call_api(params, req, runtime)
|
|
90
|
+
)
|
|
91
|
+
|
|
92
|
+
async def approve_fota_update_with_options_async(
|
|
93
|
+
self,
|
|
94
|
+
request: ecd_20201002_models.ApproveFotaUpdateRequest,
|
|
95
|
+
runtime: util_models.RuntimeOptions,
|
|
96
|
+
) -> ecd_20201002_models.ApproveFotaUpdateResponse:
|
|
97
|
+
"""
|
|
98
|
+
@summary 允许桌面FOTA升级
|
|
99
|
+
|
|
100
|
+
@param request: ApproveFotaUpdateRequest
|
|
101
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
102
|
+
@return: ApproveFotaUpdateResponse
|
|
103
|
+
"""
|
|
104
|
+
UtilClient.validate_model(request)
|
|
105
|
+
query = {}
|
|
106
|
+
if not UtilClient.is_unset(request.app_version):
|
|
107
|
+
query['AppVersion'] = request.app_version
|
|
108
|
+
if not UtilClient.is_unset(request.client_id):
|
|
109
|
+
query['ClientId'] = request.client_id
|
|
110
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
111
|
+
query['DesktopId'] = request.desktop_id
|
|
112
|
+
if not UtilClient.is_unset(request.login_token):
|
|
113
|
+
query['LoginToken'] = request.login_token
|
|
114
|
+
if not UtilClient.is_unset(request.region_id):
|
|
115
|
+
query['RegionId'] = request.region_id
|
|
116
|
+
if not UtilClient.is_unset(request.session_id):
|
|
117
|
+
query['SessionId'] = request.session_id
|
|
118
|
+
if not UtilClient.is_unset(request.uuid):
|
|
119
|
+
query['Uuid'] = request.uuid
|
|
120
|
+
req = open_api_models.OpenApiRequest(
|
|
121
|
+
query=OpenApiUtilClient.query(query)
|
|
122
|
+
)
|
|
123
|
+
params = open_api_models.Params(
|
|
124
|
+
action='ApproveFotaUpdate',
|
|
125
|
+
version='2020-10-02',
|
|
126
|
+
protocol='HTTPS',
|
|
127
|
+
pathname='/',
|
|
128
|
+
method='POST',
|
|
129
|
+
auth_type='Anonymous',
|
|
130
|
+
style='RPC',
|
|
131
|
+
req_body_type='formData',
|
|
132
|
+
body_type='json'
|
|
133
|
+
)
|
|
134
|
+
return TeaCore.from_map(
|
|
135
|
+
ecd_20201002_models.ApproveFotaUpdateResponse(),
|
|
136
|
+
await self.call_api_async(params, req, runtime)
|
|
137
|
+
)
|
|
138
|
+
|
|
139
|
+
def approve_fota_update(
|
|
140
|
+
self,
|
|
141
|
+
request: ecd_20201002_models.ApproveFotaUpdateRequest,
|
|
142
|
+
) -> ecd_20201002_models.ApproveFotaUpdateResponse:
|
|
143
|
+
"""
|
|
144
|
+
@summary 允许桌面FOTA升级
|
|
145
|
+
|
|
146
|
+
@param request: ApproveFotaUpdateRequest
|
|
147
|
+
@return: ApproveFotaUpdateResponse
|
|
148
|
+
"""
|
|
149
|
+
runtime = util_models.RuntimeOptions()
|
|
150
|
+
return self.approve_fota_update_with_options(request, runtime)
|
|
151
|
+
|
|
152
|
+
async def approve_fota_update_async(
|
|
153
|
+
self,
|
|
154
|
+
request: ecd_20201002_models.ApproveFotaUpdateRequest,
|
|
155
|
+
) -> ecd_20201002_models.ApproveFotaUpdateResponse:
|
|
156
|
+
"""
|
|
157
|
+
@summary 允许桌面FOTA升级
|
|
158
|
+
|
|
159
|
+
@param request: ApproveFotaUpdateRequest
|
|
160
|
+
@return: ApproveFotaUpdateResponse
|
|
161
|
+
"""
|
|
162
|
+
runtime = util_models.RuntimeOptions()
|
|
163
|
+
return await self.approve_fota_update_with_options_async(request, runtime)
|
|
164
|
+
|
|
165
|
+
def change_password_with_options(
|
|
166
|
+
self,
|
|
167
|
+
request: ecd_20201002_models.ChangePasswordRequest,
|
|
168
|
+
runtime: util_models.RuntimeOptions,
|
|
169
|
+
) -> ecd_20201002_models.ChangePasswordResponse:
|
|
170
|
+
"""
|
|
171
|
+
@param request: ChangePasswordRequest
|
|
172
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
173
|
+
@return: ChangePasswordResponse
|
|
174
|
+
"""
|
|
175
|
+
UtilClient.validate_model(request)
|
|
176
|
+
query = {}
|
|
177
|
+
if not UtilClient.is_unset(request.client_id):
|
|
178
|
+
query['ClientId'] = request.client_id
|
|
179
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
180
|
+
query['EndUserId'] = request.end_user_id
|
|
181
|
+
if not UtilClient.is_unset(request.login_token):
|
|
182
|
+
query['LoginToken'] = request.login_token
|
|
183
|
+
if not UtilClient.is_unset(request.new_password):
|
|
184
|
+
query['NewPassword'] = request.new_password
|
|
185
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
186
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
187
|
+
if not UtilClient.is_unset(request.old_password):
|
|
188
|
+
query['OldPassword'] = request.old_password
|
|
189
|
+
if not UtilClient.is_unset(request.region_id):
|
|
190
|
+
query['RegionId'] = request.region_id
|
|
191
|
+
if not UtilClient.is_unset(request.session_id):
|
|
192
|
+
query['SessionId'] = request.session_id
|
|
193
|
+
req = open_api_models.OpenApiRequest(
|
|
194
|
+
query=OpenApiUtilClient.query(query)
|
|
195
|
+
)
|
|
196
|
+
params = open_api_models.Params(
|
|
197
|
+
action='ChangePassword',
|
|
198
|
+
version='2020-10-02',
|
|
199
|
+
protocol='HTTPS',
|
|
200
|
+
pathname='/',
|
|
201
|
+
method='POST',
|
|
202
|
+
auth_type='Anonymous',
|
|
203
|
+
style='RPC',
|
|
204
|
+
req_body_type='formData',
|
|
205
|
+
body_type='json'
|
|
206
|
+
)
|
|
207
|
+
return TeaCore.from_map(
|
|
208
|
+
ecd_20201002_models.ChangePasswordResponse(),
|
|
209
|
+
self.call_api(params, req, runtime)
|
|
210
|
+
)
|
|
211
|
+
|
|
212
|
+
async def change_password_with_options_async(
|
|
213
|
+
self,
|
|
214
|
+
request: ecd_20201002_models.ChangePasswordRequest,
|
|
215
|
+
runtime: util_models.RuntimeOptions,
|
|
216
|
+
) -> ecd_20201002_models.ChangePasswordResponse:
|
|
217
|
+
"""
|
|
218
|
+
@param request: ChangePasswordRequest
|
|
219
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
220
|
+
@return: ChangePasswordResponse
|
|
221
|
+
"""
|
|
222
|
+
UtilClient.validate_model(request)
|
|
223
|
+
query = {}
|
|
224
|
+
if not UtilClient.is_unset(request.client_id):
|
|
225
|
+
query['ClientId'] = request.client_id
|
|
226
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
227
|
+
query['EndUserId'] = request.end_user_id
|
|
228
|
+
if not UtilClient.is_unset(request.login_token):
|
|
229
|
+
query['LoginToken'] = request.login_token
|
|
230
|
+
if not UtilClient.is_unset(request.new_password):
|
|
231
|
+
query['NewPassword'] = request.new_password
|
|
232
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
233
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
234
|
+
if not UtilClient.is_unset(request.old_password):
|
|
235
|
+
query['OldPassword'] = request.old_password
|
|
236
|
+
if not UtilClient.is_unset(request.region_id):
|
|
237
|
+
query['RegionId'] = request.region_id
|
|
238
|
+
if not UtilClient.is_unset(request.session_id):
|
|
239
|
+
query['SessionId'] = request.session_id
|
|
240
|
+
req = open_api_models.OpenApiRequest(
|
|
241
|
+
query=OpenApiUtilClient.query(query)
|
|
242
|
+
)
|
|
243
|
+
params = open_api_models.Params(
|
|
244
|
+
action='ChangePassword',
|
|
245
|
+
version='2020-10-02',
|
|
246
|
+
protocol='HTTPS',
|
|
247
|
+
pathname='/',
|
|
248
|
+
method='POST',
|
|
249
|
+
auth_type='Anonymous',
|
|
250
|
+
style='RPC',
|
|
251
|
+
req_body_type='formData',
|
|
252
|
+
body_type='json'
|
|
253
|
+
)
|
|
254
|
+
return TeaCore.from_map(
|
|
255
|
+
ecd_20201002_models.ChangePasswordResponse(),
|
|
256
|
+
await self.call_api_async(params, req, runtime)
|
|
257
|
+
)
|
|
258
|
+
|
|
259
|
+
def change_password(
|
|
260
|
+
self,
|
|
261
|
+
request: ecd_20201002_models.ChangePasswordRequest,
|
|
262
|
+
) -> ecd_20201002_models.ChangePasswordResponse:
|
|
263
|
+
"""
|
|
264
|
+
@param request: ChangePasswordRequest
|
|
265
|
+
@return: ChangePasswordResponse
|
|
266
|
+
"""
|
|
267
|
+
runtime = util_models.RuntimeOptions()
|
|
268
|
+
return self.change_password_with_options(request, runtime)
|
|
269
|
+
|
|
270
|
+
async def change_password_async(
|
|
271
|
+
self,
|
|
272
|
+
request: ecd_20201002_models.ChangePasswordRequest,
|
|
273
|
+
) -> ecd_20201002_models.ChangePasswordResponse:
|
|
274
|
+
"""
|
|
275
|
+
@param request: ChangePasswordRequest
|
|
276
|
+
@return: ChangePasswordResponse
|
|
277
|
+
"""
|
|
278
|
+
runtime = util_models.RuntimeOptions()
|
|
279
|
+
return await self.change_password_with_options_async(request, runtime)
|
|
280
|
+
|
|
281
|
+
def delete_finger_print_template_with_options(
|
|
282
|
+
self,
|
|
283
|
+
request: ecd_20201002_models.DeleteFingerPrintTemplateRequest,
|
|
284
|
+
runtime: util_models.RuntimeOptions,
|
|
285
|
+
) -> ecd_20201002_models.DeleteFingerPrintTemplateResponse:
|
|
286
|
+
"""
|
|
287
|
+
@param request: DeleteFingerPrintTemplateRequest
|
|
288
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
289
|
+
@return: DeleteFingerPrintTemplateResponse
|
|
290
|
+
"""
|
|
291
|
+
UtilClient.validate_model(request)
|
|
292
|
+
query = {}
|
|
293
|
+
if not UtilClient.is_unset(request.client_id):
|
|
294
|
+
query['ClientId'] = request.client_id
|
|
295
|
+
if not UtilClient.is_unset(request.client_token):
|
|
296
|
+
query['ClientToken'] = request.client_token
|
|
297
|
+
if not UtilClient.is_unset(request.index):
|
|
298
|
+
query['Index'] = request.index
|
|
299
|
+
if not UtilClient.is_unset(request.login_token):
|
|
300
|
+
query['LoginToken'] = request.login_token
|
|
301
|
+
if not UtilClient.is_unset(request.region_id):
|
|
302
|
+
query['RegionId'] = request.region_id
|
|
303
|
+
if not UtilClient.is_unset(request.session_id):
|
|
304
|
+
query['SessionId'] = request.session_id
|
|
305
|
+
req = open_api_models.OpenApiRequest(
|
|
306
|
+
query=OpenApiUtilClient.query(query)
|
|
307
|
+
)
|
|
308
|
+
params = open_api_models.Params(
|
|
309
|
+
action='DeleteFingerPrintTemplate',
|
|
310
|
+
version='2020-10-02',
|
|
311
|
+
protocol='HTTPS',
|
|
312
|
+
pathname='/',
|
|
313
|
+
method='POST',
|
|
314
|
+
auth_type='Anonymous',
|
|
315
|
+
style='RPC',
|
|
316
|
+
req_body_type='formData',
|
|
317
|
+
body_type='json'
|
|
318
|
+
)
|
|
319
|
+
return TeaCore.from_map(
|
|
320
|
+
ecd_20201002_models.DeleteFingerPrintTemplateResponse(),
|
|
321
|
+
self.call_api(params, req, runtime)
|
|
322
|
+
)
|
|
323
|
+
|
|
324
|
+
async def delete_finger_print_template_with_options_async(
|
|
325
|
+
self,
|
|
326
|
+
request: ecd_20201002_models.DeleteFingerPrintTemplateRequest,
|
|
327
|
+
runtime: util_models.RuntimeOptions,
|
|
328
|
+
) -> ecd_20201002_models.DeleteFingerPrintTemplateResponse:
|
|
329
|
+
"""
|
|
330
|
+
@param request: DeleteFingerPrintTemplateRequest
|
|
331
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
332
|
+
@return: DeleteFingerPrintTemplateResponse
|
|
333
|
+
"""
|
|
334
|
+
UtilClient.validate_model(request)
|
|
335
|
+
query = {}
|
|
336
|
+
if not UtilClient.is_unset(request.client_id):
|
|
337
|
+
query['ClientId'] = request.client_id
|
|
338
|
+
if not UtilClient.is_unset(request.client_token):
|
|
339
|
+
query['ClientToken'] = request.client_token
|
|
340
|
+
if not UtilClient.is_unset(request.index):
|
|
341
|
+
query['Index'] = request.index
|
|
342
|
+
if not UtilClient.is_unset(request.login_token):
|
|
343
|
+
query['LoginToken'] = request.login_token
|
|
344
|
+
if not UtilClient.is_unset(request.region_id):
|
|
345
|
+
query['RegionId'] = request.region_id
|
|
346
|
+
if not UtilClient.is_unset(request.session_id):
|
|
347
|
+
query['SessionId'] = request.session_id
|
|
348
|
+
req = open_api_models.OpenApiRequest(
|
|
349
|
+
query=OpenApiUtilClient.query(query)
|
|
350
|
+
)
|
|
351
|
+
params = open_api_models.Params(
|
|
352
|
+
action='DeleteFingerPrintTemplate',
|
|
353
|
+
version='2020-10-02',
|
|
354
|
+
protocol='HTTPS',
|
|
355
|
+
pathname='/',
|
|
356
|
+
method='POST',
|
|
357
|
+
auth_type='Anonymous',
|
|
358
|
+
style='RPC',
|
|
359
|
+
req_body_type='formData',
|
|
360
|
+
body_type='json'
|
|
361
|
+
)
|
|
362
|
+
return TeaCore.from_map(
|
|
363
|
+
ecd_20201002_models.DeleteFingerPrintTemplateResponse(),
|
|
364
|
+
await self.call_api_async(params, req, runtime)
|
|
365
|
+
)
|
|
366
|
+
|
|
367
|
+
def delete_finger_print_template(
|
|
368
|
+
self,
|
|
369
|
+
request: ecd_20201002_models.DeleteFingerPrintTemplateRequest,
|
|
370
|
+
) -> ecd_20201002_models.DeleteFingerPrintTemplateResponse:
|
|
371
|
+
"""
|
|
372
|
+
@param request: DeleteFingerPrintTemplateRequest
|
|
373
|
+
@return: DeleteFingerPrintTemplateResponse
|
|
374
|
+
"""
|
|
375
|
+
runtime = util_models.RuntimeOptions()
|
|
376
|
+
return self.delete_finger_print_template_with_options(request, runtime)
|
|
377
|
+
|
|
378
|
+
async def delete_finger_print_template_async(
|
|
379
|
+
self,
|
|
380
|
+
request: ecd_20201002_models.DeleteFingerPrintTemplateRequest,
|
|
381
|
+
) -> ecd_20201002_models.DeleteFingerPrintTemplateResponse:
|
|
382
|
+
"""
|
|
383
|
+
@param request: DeleteFingerPrintTemplateRequest
|
|
384
|
+
@return: DeleteFingerPrintTemplateResponse
|
|
385
|
+
"""
|
|
386
|
+
runtime = util_models.RuntimeOptions()
|
|
387
|
+
return await self.delete_finger_print_template_with_options_async(request, runtime)
|
|
388
|
+
|
|
389
|
+
def describe_directories_with_options(
|
|
390
|
+
self,
|
|
391
|
+
request: ecd_20201002_models.DescribeDirectoriesRequest,
|
|
392
|
+
runtime: util_models.RuntimeOptions,
|
|
393
|
+
) -> ecd_20201002_models.DescribeDirectoriesResponse:
|
|
394
|
+
"""
|
|
395
|
+
@param request: DescribeDirectoriesRequest
|
|
396
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
397
|
+
@return: DescribeDirectoriesResponse
|
|
398
|
+
"""
|
|
399
|
+
UtilClient.validate_model(request)
|
|
400
|
+
query = {}
|
|
401
|
+
if not UtilClient.is_unset(request.client_id):
|
|
402
|
+
query['ClientId'] = request.client_id
|
|
403
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
404
|
+
query['DirectoryId'] = request.directory_id
|
|
405
|
+
if not UtilClient.is_unset(request.region_id):
|
|
406
|
+
query['RegionId'] = request.region_id
|
|
407
|
+
req = open_api_models.OpenApiRequest(
|
|
408
|
+
query=OpenApiUtilClient.query(query)
|
|
409
|
+
)
|
|
410
|
+
params = open_api_models.Params(
|
|
411
|
+
action='DescribeDirectories',
|
|
412
|
+
version='2020-10-02',
|
|
413
|
+
protocol='HTTPS',
|
|
414
|
+
pathname='/',
|
|
415
|
+
method='POST',
|
|
416
|
+
auth_type='Anonymous',
|
|
417
|
+
style='RPC',
|
|
418
|
+
req_body_type='formData',
|
|
419
|
+
body_type='json'
|
|
420
|
+
)
|
|
421
|
+
return TeaCore.from_map(
|
|
422
|
+
ecd_20201002_models.DescribeDirectoriesResponse(),
|
|
423
|
+
self.call_api(params, req, runtime)
|
|
424
|
+
)
|
|
425
|
+
|
|
426
|
+
async def describe_directories_with_options_async(
|
|
427
|
+
self,
|
|
428
|
+
request: ecd_20201002_models.DescribeDirectoriesRequest,
|
|
429
|
+
runtime: util_models.RuntimeOptions,
|
|
430
|
+
) -> ecd_20201002_models.DescribeDirectoriesResponse:
|
|
431
|
+
"""
|
|
432
|
+
@param request: DescribeDirectoriesRequest
|
|
433
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
434
|
+
@return: DescribeDirectoriesResponse
|
|
435
|
+
"""
|
|
436
|
+
UtilClient.validate_model(request)
|
|
437
|
+
query = {}
|
|
438
|
+
if not UtilClient.is_unset(request.client_id):
|
|
439
|
+
query['ClientId'] = request.client_id
|
|
440
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
441
|
+
query['DirectoryId'] = request.directory_id
|
|
442
|
+
if not UtilClient.is_unset(request.region_id):
|
|
443
|
+
query['RegionId'] = request.region_id
|
|
444
|
+
req = open_api_models.OpenApiRequest(
|
|
445
|
+
query=OpenApiUtilClient.query(query)
|
|
446
|
+
)
|
|
447
|
+
params = open_api_models.Params(
|
|
448
|
+
action='DescribeDirectories',
|
|
449
|
+
version='2020-10-02',
|
|
450
|
+
protocol='HTTPS',
|
|
451
|
+
pathname='/',
|
|
452
|
+
method='POST',
|
|
453
|
+
auth_type='Anonymous',
|
|
454
|
+
style='RPC',
|
|
455
|
+
req_body_type='formData',
|
|
456
|
+
body_type='json'
|
|
457
|
+
)
|
|
458
|
+
return TeaCore.from_map(
|
|
459
|
+
ecd_20201002_models.DescribeDirectoriesResponse(),
|
|
460
|
+
await self.call_api_async(params, req, runtime)
|
|
461
|
+
)
|
|
462
|
+
|
|
463
|
+
def describe_directories(
|
|
464
|
+
self,
|
|
465
|
+
request: ecd_20201002_models.DescribeDirectoriesRequest,
|
|
466
|
+
) -> ecd_20201002_models.DescribeDirectoriesResponse:
|
|
467
|
+
"""
|
|
468
|
+
@param request: DescribeDirectoriesRequest
|
|
469
|
+
@return: DescribeDirectoriesResponse
|
|
470
|
+
"""
|
|
471
|
+
runtime = util_models.RuntimeOptions()
|
|
472
|
+
return self.describe_directories_with_options(request, runtime)
|
|
473
|
+
|
|
474
|
+
async def describe_directories_async(
|
|
475
|
+
self,
|
|
476
|
+
request: ecd_20201002_models.DescribeDirectoriesRequest,
|
|
477
|
+
) -> ecd_20201002_models.DescribeDirectoriesResponse:
|
|
478
|
+
"""
|
|
479
|
+
@param request: DescribeDirectoriesRequest
|
|
480
|
+
@return: DescribeDirectoriesResponse
|
|
481
|
+
"""
|
|
482
|
+
runtime = util_models.RuntimeOptions()
|
|
483
|
+
return await self.describe_directories_with_options_async(request, runtime)
|
|
484
|
+
|
|
485
|
+
def describe_finger_print_templates_with_options(
|
|
486
|
+
self,
|
|
487
|
+
request: ecd_20201002_models.DescribeFingerPrintTemplatesRequest,
|
|
488
|
+
runtime: util_models.RuntimeOptions,
|
|
489
|
+
) -> ecd_20201002_models.DescribeFingerPrintTemplatesResponse:
|
|
490
|
+
"""
|
|
491
|
+
@param request: DescribeFingerPrintTemplatesRequest
|
|
492
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
493
|
+
@return: DescribeFingerPrintTemplatesResponse
|
|
494
|
+
"""
|
|
495
|
+
UtilClient.validate_model(request)
|
|
496
|
+
query = {}
|
|
497
|
+
if not UtilClient.is_unset(request.client_id):
|
|
498
|
+
query['ClientId'] = request.client_id
|
|
499
|
+
if not UtilClient.is_unset(request.login_token):
|
|
500
|
+
query['LoginToken'] = request.login_token
|
|
501
|
+
if not UtilClient.is_unset(request.region_id):
|
|
502
|
+
query['RegionId'] = request.region_id
|
|
503
|
+
if not UtilClient.is_unset(request.session_id):
|
|
504
|
+
query['SessionId'] = request.session_id
|
|
505
|
+
req = open_api_models.OpenApiRequest(
|
|
506
|
+
query=OpenApiUtilClient.query(query)
|
|
507
|
+
)
|
|
508
|
+
params = open_api_models.Params(
|
|
509
|
+
action='DescribeFingerPrintTemplates',
|
|
510
|
+
version='2020-10-02',
|
|
511
|
+
protocol='HTTPS',
|
|
512
|
+
pathname='/',
|
|
513
|
+
method='POST',
|
|
514
|
+
auth_type='Anonymous',
|
|
515
|
+
style='RPC',
|
|
516
|
+
req_body_type='formData',
|
|
517
|
+
body_type='json'
|
|
518
|
+
)
|
|
519
|
+
return TeaCore.from_map(
|
|
520
|
+
ecd_20201002_models.DescribeFingerPrintTemplatesResponse(),
|
|
521
|
+
self.call_api(params, req, runtime)
|
|
522
|
+
)
|
|
523
|
+
|
|
524
|
+
async def describe_finger_print_templates_with_options_async(
|
|
525
|
+
self,
|
|
526
|
+
request: ecd_20201002_models.DescribeFingerPrintTemplatesRequest,
|
|
527
|
+
runtime: util_models.RuntimeOptions,
|
|
528
|
+
) -> ecd_20201002_models.DescribeFingerPrintTemplatesResponse:
|
|
529
|
+
"""
|
|
530
|
+
@param request: DescribeFingerPrintTemplatesRequest
|
|
531
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
532
|
+
@return: DescribeFingerPrintTemplatesResponse
|
|
533
|
+
"""
|
|
534
|
+
UtilClient.validate_model(request)
|
|
535
|
+
query = {}
|
|
536
|
+
if not UtilClient.is_unset(request.client_id):
|
|
537
|
+
query['ClientId'] = request.client_id
|
|
538
|
+
if not UtilClient.is_unset(request.login_token):
|
|
539
|
+
query['LoginToken'] = request.login_token
|
|
540
|
+
if not UtilClient.is_unset(request.region_id):
|
|
541
|
+
query['RegionId'] = request.region_id
|
|
542
|
+
if not UtilClient.is_unset(request.session_id):
|
|
543
|
+
query['SessionId'] = request.session_id
|
|
544
|
+
req = open_api_models.OpenApiRequest(
|
|
545
|
+
query=OpenApiUtilClient.query(query)
|
|
546
|
+
)
|
|
547
|
+
params = open_api_models.Params(
|
|
548
|
+
action='DescribeFingerPrintTemplates',
|
|
549
|
+
version='2020-10-02',
|
|
550
|
+
protocol='HTTPS',
|
|
551
|
+
pathname='/',
|
|
552
|
+
method='POST',
|
|
553
|
+
auth_type='Anonymous',
|
|
554
|
+
style='RPC',
|
|
555
|
+
req_body_type='formData',
|
|
556
|
+
body_type='json'
|
|
557
|
+
)
|
|
558
|
+
return TeaCore.from_map(
|
|
559
|
+
ecd_20201002_models.DescribeFingerPrintTemplatesResponse(),
|
|
560
|
+
await self.call_api_async(params, req, runtime)
|
|
561
|
+
)
|
|
562
|
+
|
|
563
|
+
def describe_finger_print_templates(
|
|
564
|
+
self,
|
|
565
|
+
request: ecd_20201002_models.DescribeFingerPrintTemplatesRequest,
|
|
566
|
+
) -> ecd_20201002_models.DescribeFingerPrintTemplatesResponse:
|
|
567
|
+
"""
|
|
568
|
+
@param request: DescribeFingerPrintTemplatesRequest
|
|
569
|
+
@return: DescribeFingerPrintTemplatesResponse
|
|
570
|
+
"""
|
|
571
|
+
runtime = util_models.RuntimeOptions()
|
|
572
|
+
return self.describe_finger_print_templates_with_options(request, runtime)
|
|
573
|
+
|
|
574
|
+
async def describe_finger_print_templates_async(
|
|
575
|
+
self,
|
|
576
|
+
request: ecd_20201002_models.DescribeFingerPrintTemplatesRequest,
|
|
577
|
+
) -> ecd_20201002_models.DescribeFingerPrintTemplatesResponse:
|
|
578
|
+
"""
|
|
579
|
+
@param request: DescribeFingerPrintTemplatesRequest
|
|
580
|
+
@return: DescribeFingerPrintTemplatesResponse
|
|
581
|
+
"""
|
|
582
|
+
runtime = util_models.RuntimeOptions()
|
|
583
|
+
return await self.describe_finger_print_templates_with_options_async(request, runtime)
|
|
584
|
+
|
|
585
|
+
def describe_global_desktops_with_options(
|
|
586
|
+
self,
|
|
587
|
+
request: ecd_20201002_models.DescribeGlobalDesktopsRequest,
|
|
588
|
+
runtime: util_models.RuntimeOptions,
|
|
589
|
+
) -> ecd_20201002_models.DescribeGlobalDesktopsResponse:
|
|
590
|
+
"""
|
|
591
|
+
@param request: DescribeGlobalDesktopsRequest
|
|
592
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
593
|
+
@return: DescribeGlobalDesktopsResponse
|
|
594
|
+
"""
|
|
595
|
+
UtilClient.validate_model(request)
|
|
596
|
+
query = {}
|
|
597
|
+
if not UtilClient.is_unset(request.client_id):
|
|
598
|
+
query['ClientId'] = request.client_id
|
|
599
|
+
if not UtilClient.is_unset(request.desktop_access_type):
|
|
600
|
+
query['DesktopAccessType'] = request.desktop_access_type
|
|
601
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
602
|
+
query['DesktopId'] = request.desktop_id
|
|
603
|
+
if not UtilClient.is_unset(request.desktop_name):
|
|
604
|
+
query['DesktopName'] = request.desktop_name
|
|
605
|
+
if not UtilClient.is_unset(request.desktop_status):
|
|
606
|
+
query['DesktopStatus'] = request.desktop_status
|
|
607
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
608
|
+
query['DirectoryId'] = request.directory_id
|
|
609
|
+
if not UtilClient.is_unset(request.keyword):
|
|
610
|
+
query['Keyword'] = request.keyword
|
|
611
|
+
if not UtilClient.is_unset(request.language):
|
|
612
|
+
query['Language'] = request.language
|
|
613
|
+
if not UtilClient.is_unset(request.login_region_id):
|
|
614
|
+
query['LoginRegionId'] = request.login_region_id
|
|
615
|
+
if not UtilClient.is_unset(request.login_token):
|
|
616
|
+
query['LoginToken'] = request.login_token
|
|
617
|
+
if not UtilClient.is_unset(request.max_results):
|
|
618
|
+
query['MaxResults'] = request.max_results
|
|
619
|
+
if not UtilClient.is_unset(request.next_token):
|
|
620
|
+
query['NextToken'] = request.next_token
|
|
621
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
622
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
623
|
+
if not UtilClient.is_unset(request.order_by):
|
|
624
|
+
query['OrderBy'] = request.order_by
|
|
625
|
+
if not UtilClient.is_unset(request.query_fota_update):
|
|
626
|
+
query['QueryFotaUpdate'] = request.query_fota_update
|
|
627
|
+
if not UtilClient.is_unset(request.region_id):
|
|
628
|
+
query['RegionId'] = request.region_id
|
|
629
|
+
if not UtilClient.is_unset(request.search_region_id):
|
|
630
|
+
query['SearchRegionId'] = request.search_region_id
|
|
631
|
+
if not UtilClient.is_unset(request.session_id):
|
|
632
|
+
query['SessionId'] = request.session_id
|
|
633
|
+
if not UtilClient.is_unset(request.sort_type):
|
|
634
|
+
query['SortType'] = request.sort_type
|
|
635
|
+
if not UtilClient.is_unset(request.without_latency):
|
|
636
|
+
query['WithoutLatency'] = request.without_latency
|
|
637
|
+
req = open_api_models.OpenApiRequest(
|
|
638
|
+
query=OpenApiUtilClient.query(query)
|
|
639
|
+
)
|
|
640
|
+
params = open_api_models.Params(
|
|
641
|
+
action='DescribeGlobalDesktops',
|
|
642
|
+
version='2020-10-02',
|
|
643
|
+
protocol='HTTPS',
|
|
644
|
+
pathname='/',
|
|
645
|
+
method='POST',
|
|
646
|
+
auth_type='Anonymous',
|
|
647
|
+
style='RPC',
|
|
648
|
+
req_body_type='formData',
|
|
649
|
+
body_type='json'
|
|
650
|
+
)
|
|
651
|
+
return TeaCore.from_map(
|
|
652
|
+
ecd_20201002_models.DescribeGlobalDesktopsResponse(),
|
|
653
|
+
self.call_api(params, req, runtime)
|
|
654
|
+
)
|
|
655
|
+
|
|
656
|
+
async def describe_global_desktops_with_options_async(
|
|
657
|
+
self,
|
|
658
|
+
request: ecd_20201002_models.DescribeGlobalDesktopsRequest,
|
|
659
|
+
runtime: util_models.RuntimeOptions,
|
|
660
|
+
) -> ecd_20201002_models.DescribeGlobalDesktopsResponse:
|
|
661
|
+
"""
|
|
662
|
+
@param request: DescribeGlobalDesktopsRequest
|
|
663
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
664
|
+
@return: DescribeGlobalDesktopsResponse
|
|
665
|
+
"""
|
|
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.desktop_access_type):
|
|
671
|
+
query['DesktopAccessType'] = request.desktop_access_type
|
|
672
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
673
|
+
query['DesktopId'] = request.desktop_id
|
|
674
|
+
if not UtilClient.is_unset(request.desktop_name):
|
|
675
|
+
query['DesktopName'] = request.desktop_name
|
|
676
|
+
if not UtilClient.is_unset(request.desktop_status):
|
|
677
|
+
query['DesktopStatus'] = request.desktop_status
|
|
678
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
679
|
+
query['DirectoryId'] = request.directory_id
|
|
680
|
+
if not UtilClient.is_unset(request.keyword):
|
|
681
|
+
query['Keyword'] = request.keyword
|
|
682
|
+
if not UtilClient.is_unset(request.language):
|
|
683
|
+
query['Language'] = request.language
|
|
684
|
+
if not UtilClient.is_unset(request.login_region_id):
|
|
685
|
+
query['LoginRegionId'] = request.login_region_id
|
|
686
|
+
if not UtilClient.is_unset(request.login_token):
|
|
687
|
+
query['LoginToken'] = request.login_token
|
|
688
|
+
if not UtilClient.is_unset(request.max_results):
|
|
689
|
+
query['MaxResults'] = request.max_results
|
|
690
|
+
if not UtilClient.is_unset(request.next_token):
|
|
691
|
+
query['NextToken'] = request.next_token
|
|
692
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
693
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
694
|
+
if not UtilClient.is_unset(request.order_by):
|
|
695
|
+
query['OrderBy'] = request.order_by
|
|
696
|
+
if not UtilClient.is_unset(request.query_fota_update):
|
|
697
|
+
query['QueryFotaUpdate'] = request.query_fota_update
|
|
698
|
+
if not UtilClient.is_unset(request.region_id):
|
|
699
|
+
query['RegionId'] = request.region_id
|
|
700
|
+
if not UtilClient.is_unset(request.search_region_id):
|
|
701
|
+
query['SearchRegionId'] = request.search_region_id
|
|
702
|
+
if not UtilClient.is_unset(request.session_id):
|
|
703
|
+
query['SessionId'] = request.session_id
|
|
704
|
+
if not UtilClient.is_unset(request.sort_type):
|
|
705
|
+
query['SortType'] = request.sort_type
|
|
706
|
+
if not UtilClient.is_unset(request.without_latency):
|
|
707
|
+
query['WithoutLatency'] = request.without_latency
|
|
708
|
+
req = open_api_models.OpenApiRequest(
|
|
709
|
+
query=OpenApiUtilClient.query(query)
|
|
710
|
+
)
|
|
711
|
+
params = open_api_models.Params(
|
|
712
|
+
action='DescribeGlobalDesktops',
|
|
713
|
+
version='2020-10-02',
|
|
714
|
+
protocol='HTTPS',
|
|
715
|
+
pathname='/',
|
|
716
|
+
method='POST',
|
|
717
|
+
auth_type='Anonymous',
|
|
718
|
+
style='RPC',
|
|
719
|
+
req_body_type='formData',
|
|
720
|
+
body_type='json'
|
|
721
|
+
)
|
|
722
|
+
return TeaCore.from_map(
|
|
723
|
+
ecd_20201002_models.DescribeGlobalDesktopsResponse(),
|
|
724
|
+
await self.call_api_async(params, req, runtime)
|
|
725
|
+
)
|
|
726
|
+
|
|
727
|
+
def describe_global_desktops(
|
|
728
|
+
self,
|
|
729
|
+
request: ecd_20201002_models.DescribeGlobalDesktopsRequest,
|
|
730
|
+
) -> ecd_20201002_models.DescribeGlobalDesktopsResponse:
|
|
731
|
+
"""
|
|
732
|
+
@param request: DescribeGlobalDesktopsRequest
|
|
733
|
+
@return: DescribeGlobalDesktopsResponse
|
|
734
|
+
"""
|
|
735
|
+
runtime = util_models.RuntimeOptions()
|
|
736
|
+
return self.describe_global_desktops_with_options(request, runtime)
|
|
737
|
+
|
|
738
|
+
async def describe_global_desktops_async(
|
|
739
|
+
self,
|
|
740
|
+
request: ecd_20201002_models.DescribeGlobalDesktopsRequest,
|
|
741
|
+
) -> ecd_20201002_models.DescribeGlobalDesktopsResponse:
|
|
742
|
+
"""
|
|
743
|
+
@param request: DescribeGlobalDesktopsRequest
|
|
744
|
+
@return: DescribeGlobalDesktopsResponse
|
|
745
|
+
"""
|
|
746
|
+
runtime = util_models.RuntimeOptions()
|
|
747
|
+
return await self.describe_global_desktops_with_options_async(request, runtime)
|
|
748
|
+
|
|
749
|
+
def describe_office_sites_with_options(
|
|
750
|
+
self,
|
|
751
|
+
request: ecd_20201002_models.DescribeOfficeSitesRequest,
|
|
752
|
+
runtime: util_models.RuntimeOptions,
|
|
753
|
+
) -> ecd_20201002_models.DescribeOfficeSitesResponse:
|
|
754
|
+
"""
|
|
755
|
+
@param request: DescribeOfficeSitesRequest
|
|
756
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
757
|
+
@return: DescribeOfficeSitesResponse
|
|
758
|
+
"""
|
|
759
|
+
UtilClient.validate_model(request)
|
|
760
|
+
query = {}
|
|
761
|
+
if not UtilClient.is_unset(request.client_id):
|
|
762
|
+
query['ClientId'] = request.client_id
|
|
763
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
764
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
765
|
+
if not UtilClient.is_unset(request.region_id):
|
|
766
|
+
query['RegionId'] = request.region_id
|
|
767
|
+
req = open_api_models.OpenApiRequest(
|
|
768
|
+
query=OpenApiUtilClient.query(query)
|
|
769
|
+
)
|
|
770
|
+
params = open_api_models.Params(
|
|
771
|
+
action='DescribeOfficeSites',
|
|
772
|
+
version='2020-10-02',
|
|
773
|
+
protocol='HTTPS',
|
|
774
|
+
pathname='/',
|
|
775
|
+
method='POST',
|
|
776
|
+
auth_type='Anonymous',
|
|
777
|
+
style='RPC',
|
|
778
|
+
req_body_type='formData',
|
|
779
|
+
body_type='json'
|
|
780
|
+
)
|
|
781
|
+
return TeaCore.from_map(
|
|
782
|
+
ecd_20201002_models.DescribeOfficeSitesResponse(),
|
|
783
|
+
self.call_api(params, req, runtime)
|
|
784
|
+
)
|
|
785
|
+
|
|
786
|
+
async def describe_office_sites_with_options_async(
|
|
787
|
+
self,
|
|
788
|
+
request: ecd_20201002_models.DescribeOfficeSitesRequest,
|
|
789
|
+
runtime: util_models.RuntimeOptions,
|
|
790
|
+
) -> ecd_20201002_models.DescribeOfficeSitesResponse:
|
|
791
|
+
"""
|
|
792
|
+
@param request: DescribeOfficeSitesRequest
|
|
793
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
794
|
+
@return: DescribeOfficeSitesResponse
|
|
795
|
+
"""
|
|
796
|
+
UtilClient.validate_model(request)
|
|
797
|
+
query = {}
|
|
798
|
+
if not UtilClient.is_unset(request.client_id):
|
|
799
|
+
query['ClientId'] = request.client_id
|
|
800
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
801
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
802
|
+
if not UtilClient.is_unset(request.region_id):
|
|
803
|
+
query['RegionId'] = request.region_id
|
|
804
|
+
req = open_api_models.OpenApiRequest(
|
|
805
|
+
query=OpenApiUtilClient.query(query)
|
|
806
|
+
)
|
|
807
|
+
params = open_api_models.Params(
|
|
808
|
+
action='DescribeOfficeSites',
|
|
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.DescribeOfficeSitesResponse(),
|
|
820
|
+
await self.call_api_async(params, req, runtime)
|
|
821
|
+
)
|
|
822
|
+
|
|
823
|
+
def describe_office_sites(
|
|
824
|
+
self,
|
|
825
|
+
request: ecd_20201002_models.DescribeOfficeSitesRequest,
|
|
826
|
+
) -> ecd_20201002_models.DescribeOfficeSitesResponse:
|
|
827
|
+
"""
|
|
828
|
+
@param request: DescribeOfficeSitesRequest
|
|
829
|
+
@return: DescribeOfficeSitesResponse
|
|
830
|
+
"""
|
|
831
|
+
runtime = util_models.RuntimeOptions()
|
|
832
|
+
return self.describe_office_sites_with_options(request, runtime)
|
|
833
|
+
|
|
834
|
+
async def describe_office_sites_async(
|
|
835
|
+
self,
|
|
836
|
+
request: ecd_20201002_models.DescribeOfficeSitesRequest,
|
|
837
|
+
) -> ecd_20201002_models.DescribeOfficeSitesResponse:
|
|
838
|
+
"""
|
|
839
|
+
@param request: DescribeOfficeSitesRequest
|
|
840
|
+
@return: DescribeOfficeSitesResponse
|
|
841
|
+
"""
|
|
842
|
+
runtime = util_models.RuntimeOptions()
|
|
843
|
+
return await self.describe_office_sites_with_options_async(request, runtime)
|
|
844
|
+
|
|
845
|
+
def describe_regions_with_options(
|
|
846
|
+
self,
|
|
847
|
+
request: ecd_20201002_models.DescribeRegionsRequest,
|
|
848
|
+
runtime: util_models.RuntimeOptions,
|
|
849
|
+
) -> ecd_20201002_models.DescribeRegionsResponse:
|
|
850
|
+
"""
|
|
851
|
+
@param request: DescribeRegionsRequest
|
|
852
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
853
|
+
@return: DescribeRegionsResponse
|
|
854
|
+
"""
|
|
855
|
+
UtilClient.validate_model(request)
|
|
856
|
+
query = {}
|
|
857
|
+
if not UtilClient.is_unset(request.client_id):
|
|
858
|
+
query['ClientId'] = request.client_id
|
|
859
|
+
if not UtilClient.is_unset(request.region_id):
|
|
860
|
+
query['RegionId'] = request.region_id
|
|
861
|
+
req = open_api_models.OpenApiRequest(
|
|
862
|
+
query=OpenApiUtilClient.query(query)
|
|
863
|
+
)
|
|
864
|
+
params = open_api_models.Params(
|
|
865
|
+
action='DescribeRegions',
|
|
866
|
+
version='2020-10-02',
|
|
867
|
+
protocol='HTTPS',
|
|
868
|
+
pathname='/',
|
|
869
|
+
method='POST',
|
|
870
|
+
auth_type='Anonymous',
|
|
871
|
+
style='RPC',
|
|
872
|
+
req_body_type='formData',
|
|
873
|
+
body_type='json'
|
|
874
|
+
)
|
|
875
|
+
return TeaCore.from_map(
|
|
876
|
+
ecd_20201002_models.DescribeRegionsResponse(),
|
|
877
|
+
self.call_api(params, req, runtime)
|
|
878
|
+
)
|
|
879
|
+
|
|
880
|
+
async def describe_regions_with_options_async(
|
|
881
|
+
self,
|
|
882
|
+
request: ecd_20201002_models.DescribeRegionsRequest,
|
|
883
|
+
runtime: util_models.RuntimeOptions,
|
|
884
|
+
) -> ecd_20201002_models.DescribeRegionsResponse:
|
|
885
|
+
"""
|
|
886
|
+
@param request: DescribeRegionsRequest
|
|
887
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
888
|
+
@return: DescribeRegionsResponse
|
|
889
|
+
"""
|
|
890
|
+
UtilClient.validate_model(request)
|
|
891
|
+
query = {}
|
|
892
|
+
if not UtilClient.is_unset(request.client_id):
|
|
893
|
+
query['ClientId'] = request.client_id
|
|
894
|
+
if not UtilClient.is_unset(request.region_id):
|
|
895
|
+
query['RegionId'] = request.region_id
|
|
896
|
+
req = open_api_models.OpenApiRequest(
|
|
897
|
+
query=OpenApiUtilClient.query(query)
|
|
898
|
+
)
|
|
899
|
+
params = open_api_models.Params(
|
|
900
|
+
action='DescribeRegions',
|
|
901
|
+
version='2020-10-02',
|
|
902
|
+
protocol='HTTPS',
|
|
903
|
+
pathname='/',
|
|
904
|
+
method='POST',
|
|
905
|
+
auth_type='Anonymous',
|
|
906
|
+
style='RPC',
|
|
907
|
+
req_body_type='formData',
|
|
908
|
+
body_type='json'
|
|
909
|
+
)
|
|
910
|
+
return TeaCore.from_map(
|
|
911
|
+
ecd_20201002_models.DescribeRegionsResponse(),
|
|
912
|
+
await self.call_api_async(params, req, runtime)
|
|
913
|
+
)
|
|
914
|
+
|
|
915
|
+
def describe_regions(
|
|
916
|
+
self,
|
|
917
|
+
request: ecd_20201002_models.DescribeRegionsRequest,
|
|
918
|
+
) -> ecd_20201002_models.DescribeRegionsResponse:
|
|
919
|
+
"""
|
|
920
|
+
@param request: DescribeRegionsRequest
|
|
921
|
+
@return: DescribeRegionsResponse
|
|
922
|
+
"""
|
|
923
|
+
runtime = util_models.RuntimeOptions()
|
|
924
|
+
return self.describe_regions_with_options(request, runtime)
|
|
925
|
+
|
|
926
|
+
async def describe_regions_async(
|
|
927
|
+
self,
|
|
928
|
+
request: ecd_20201002_models.DescribeRegionsRequest,
|
|
929
|
+
) -> ecd_20201002_models.DescribeRegionsResponse:
|
|
930
|
+
"""
|
|
931
|
+
@param request: DescribeRegionsRequest
|
|
932
|
+
@return: DescribeRegionsResponse
|
|
933
|
+
"""
|
|
934
|
+
runtime = util_models.RuntimeOptions()
|
|
935
|
+
return await self.describe_regions_with_options_async(request, runtime)
|
|
936
|
+
|
|
937
|
+
def describe_snapshots_with_options(
|
|
938
|
+
self,
|
|
939
|
+
request: ecd_20201002_models.DescribeSnapshotsRequest,
|
|
940
|
+
runtime: util_models.RuntimeOptions,
|
|
941
|
+
) -> ecd_20201002_models.DescribeSnapshotsResponse:
|
|
942
|
+
"""
|
|
943
|
+
@summary 列举快照
|
|
944
|
+
|
|
945
|
+
@param request: DescribeSnapshotsRequest
|
|
946
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
947
|
+
@return: DescribeSnapshotsResponse
|
|
948
|
+
"""
|
|
949
|
+
UtilClient.validate_model(request)
|
|
950
|
+
query = {}
|
|
951
|
+
if not UtilClient.is_unset(request.client_id):
|
|
952
|
+
query['ClientId'] = request.client_id
|
|
953
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
954
|
+
query['DesktopId'] = request.desktop_id
|
|
955
|
+
if not UtilClient.is_unset(request.login_token):
|
|
956
|
+
query['LoginToken'] = request.login_token
|
|
957
|
+
if not UtilClient.is_unset(request.max_results):
|
|
958
|
+
query['MaxResults'] = request.max_results
|
|
959
|
+
if not UtilClient.is_unset(request.next_token):
|
|
960
|
+
query['NextToken'] = request.next_token
|
|
961
|
+
if not UtilClient.is_unset(request.region_id):
|
|
962
|
+
query['RegionId'] = request.region_id
|
|
963
|
+
if not UtilClient.is_unset(request.session_id):
|
|
964
|
+
query['SessionId'] = request.session_id
|
|
965
|
+
if not UtilClient.is_unset(request.snapshot_id):
|
|
966
|
+
query['SnapshotId'] = request.snapshot_id
|
|
967
|
+
req = open_api_models.OpenApiRequest(
|
|
968
|
+
query=OpenApiUtilClient.query(query)
|
|
969
|
+
)
|
|
970
|
+
params = open_api_models.Params(
|
|
971
|
+
action='DescribeSnapshots',
|
|
972
|
+
version='2020-10-02',
|
|
973
|
+
protocol='HTTPS',
|
|
974
|
+
pathname='/',
|
|
975
|
+
method='POST',
|
|
976
|
+
auth_type='Anonymous',
|
|
977
|
+
style='RPC',
|
|
978
|
+
req_body_type='formData',
|
|
979
|
+
body_type='json'
|
|
980
|
+
)
|
|
981
|
+
return TeaCore.from_map(
|
|
982
|
+
ecd_20201002_models.DescribeSnapshotsResponse(),
|
|
983
|
+
self.call_api(params, req, runtime)
|
|
984
|
+
)
|
|
985
|
+
|
|
986
|
+
async def describe_snapshots_with_options_async(
|
|
987
|
+
self,
|
|
988
|
+
request: ecd_20201002_models.DescribeSnapshotsRequest,
|
|
989
|
+
runtime: util_models.RuntimeOptions,
|
|
990
|
+
) -> ecd_20201002_models.DescribeSnapshotsResponse:
|
|
991
|
+
"""
|
|
992
|
+
@summary 列举快照
|
|
993
|
+
|
|
994
|
+
@param request: DescribeSnapshotsRequest
|
|
995
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
996
|
+
@return: DescribeSnapshotsResponse
|
|
997
|
+
"""
|
|
998
|
+
UtilClient.validate_model(request)
|
|
999
|
+
query = {}
|
|
1000
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1001
|
+
query['ClientId'] = request.client_id
|
|
1002
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1003
|
+
query['DesktopId'] = request.desktop_id
|
|
1004
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1005
|
+
query['LoginToken'] = request.login_token
|
|
1006
|
+
if not UtilClient.is_unset(request.max_results):
|
|
1007
|
+
query['MaxResults'] = request.max_results
|
|
1008
|
+
if not UtilClient.is_unset(request.next_token):
|
|
1009
|
+
query['NextToken'] = request.next_token
|
|
1010
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1011
|
+
query['RegionId'] = request.region_id
|
|
1012
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1013
|
+
query['SessionId'] = request.session_id
|
|
1014
|
+
if not UtilClient.is_unset(request.snapshot_id):
|
|
1015
|
+
query['SnapshotId'] = request.snapshot_id
|
|
1016
|
+
req = open_api_models.OpenApiRequest(
|
|
1017
|
+
query=OpenApiUtilClient.query(query)
|
|
1018
|
+
)
|
|
1019
|
+
params = open_api_models.Params(
|
|
1020
|
+
action='DescribeSnapshots',
|
|
1021
|
+
version='2020-10-02',
|
|
1022
|
+
protocol='HTTPS',
|
|
1023
|
+
pathname='/',
|
|
1024
|
+
method='POST',
|
|
1025
|
+
auth_type='Anonymous',
|
|
1026
|
+
style='RPC',
|
|
1027
|
+
req_body_type='formData',
|
|
1028
|
+
body_type='json'
|
|
1029
|
+
)
|
|
1030
|
+
return TeaCore.from_map(
|
|
1031
|
+
ecd_20201002_models.DescribeSnapshotsResponse(),
|
|
1032
|
+
await self.call_api_async(params, req, runtime)
|
|
1033
|
+
)
|
|
1034
|
+
|
|
1035
|
+
def describe_snapshots(
|
|
1036
|
+
self,
|
|
1037
|
+
request: ecd_20201002_models.DescribeSnapshotsRequest,
|
|
1038
|
+
) -> ecd_20201002_models.DescribeSnapshotsResponse:
|
|
1039
|
+
"""
|
|
1040
|
+
@summary 列举快照
|
|
1041
|
+
|
|
1042
|
+
@param request: DescribeSnapshotsRequest
|
|
1043
|
+
@return: DescribeSnapshotsResponse
|
|
1044
|
+
"""
|
|
1045
|
+
runtime = util_models.RuntimeOptions()
|
|
1046
|
+
return self.describe_snapshots_with_options(request, runtime)
|
|
1047
|
+
|
|
1048
|
+
async def describe_snapshots_async(
|
|
1049
|
+
self,
|
|
1050
|
+
request: ecd_20201002_models.DescribeSnapshotsRequest,
|
|
1051
|
+
) -> ecd_20201002_models.DescribeSnapshotsResponse:
|
|
1052
|
+
"""
|
|
1053
|
+
@summary 列举快照
|
|
1054
|
+
|
|
1055
|
+
@param request: DescribeSnapshotsRequest
|
|
1056
|
+
@return: DescribeSnapshotsResponse
|
|
1057
|
+
"""
|
|
1058
|
+
runtime = util_models.RuntimeOptions()
|
|
1059
|
+
return await self.describe_snapshots_with_options_async(request, runtime)
|
|
1060
|
+
|
|
1061
|
+
def encrypt_password_with_options(
|
|
1062
|
+
self,
|
|
1063
|
+
request: ecd_20201002_models.EncryptPasswordRequest,
|
|
1064
|
+
runtime: util_models.RuntimeOptions,
|
|
1065
|
+
) -> ecd_20201002_models.EncryptPasswordResponse:
|
|
1066
|
+
"""
|
|
1067
|
+
@param request: EncryptPasswordRequest
|
|
1068
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1069
|
+
@return: EncryptPasswordResponse
|
|
1070
|
+
"""
|
|
1071
|
+
UtilClient.validate_model(request)
|
|
1072
|
+
query = {}
|
|
1073
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1074
|
+
query['ClientId'] = request.client_id
|
|
1075
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
1076
|
+
query['DirectoryId'] = request.directory_id
|
|
1077
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1078
|
+
query['LoginToken'] = request.login_token
|
|
1079
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1080
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1081
|
+
if not UtilClient.is_unset(request.password):
|
|
1082
|
+
query['Password'] = request.password
|
|
1083
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1084
|
+
query['RegionId'] = request.region_id
|
|
1085
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1086
|
+
query['SessionId'] = request.session_id
|
|
1087
|
+
req = open_api_models.OpenApiRequest(
|
|
1088
|
+
query=OpenApiUtilClient.query(query)
|
|
1089
|
+
)
|
|
1090
|
+
params = open_api_models.Params(
|
|
1091
|
+
action='EncryptPassword',
|
|
1092
|
+
version='2020-10-02',
|
|
1093
|
+
protocol='HTTPS',
|
|
1094
|
+
pathname='/',
|
|
1095
|
+
method='POST',
|
|
1096
|
+
auth_type='Anonymous',
|
|
1097
|
+
style='RPC',
|
|
1098
|
+
req_body_type='formData',
|
|
1099
|
+
body_type='json'
|
|
1100
|
+
)
|
|
1101
|
+
return TeaCore.from_map(
|
|
1102
|
+
ecd_20201002_models.EncryptPasswordResponse(),
|
|
1103
|
+
self.call_api(params, req, runtime)
|
|
1104
|
+
)
|
|
1105
|
+
|
|
1106
|
+
async def encrypt_password_with_options_async(
|
|
1107
|
+
self,
|
|
1108
|
+
request: ecd_20201002_models.EncryptPasswordRequest,
|
|
1109
|
+
runtime: util_models.RuntimeOptions,
|
|
1110
|
+
) -> ecd_20201002_models.EncryptPasswordResponse:
|
|
1111
|
+
"""
|
|
1112
|
+
@param request: EncryptPasswordRequest
|
|
1113
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1114
|
+
@return: EncryptPasswordResponse
|
|
1115
|
+
"""
|
|
1116
|
+
UtilClient.validate_model(request)
|
|
1117
|
+
query = {}
|
|
1118
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1119
|
+
query['ClientId'] = request.client_id
|
|
1120
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
1121
|
+
query['DirectoryId'] = request.directory_id
|
|
1122
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1123
|
+
query['LoginToken'] = request.login_token
|
|
1124
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1125
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1126
|
+
if not UtilClient.is_unset(request.password):
|
|
1127
|
+
query['Password'] = request.password
|
|
1128
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1129
|
+
query['RegionId'] = request.region_id
|
|
1130
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1131
|
+
query['SessionId'] = request.session_id
|
|
1132
|
+
req = open_api_models.OpenApiRequest(
|
|
1133
|
+
query=OpenApiUtilClient.query(query)
|
|
1134
|
+
)
|
|
1135
|
+
params = open_api_models.Params(
|
|
1136
|
+
action='EncryptPassword',
|
|
1137
|
+
version='2020-10-02',
|
|
1138
|
+
protocol='HTTPS',
|
|
1139
|
+
pathname='/',
|
|
1140
|
+
method='POST',
|
|
1141
|
+
auth_type='Anonymous',
|
|
1142
|
+
style='RPC',
|
|
1143
|
+
req_body_type='formData',
|
|
1144
|
+
body_type='json'
|
|
1145
|
+
)
|
|
1146
|
+
return TeaCore.from_map(
|
|
1147
|
+
ecd_20201002_models.EncryptPasswordResponse(),
|
|
1148
|
+
await self.call_api_async(params, req, runtime)
|
|
1149
|
+
)
|
|
1150
|
+
|
|
1151
|
+
def encrypt_password(
|
|
1152
|
+
self,
|
|
1153
|
+
request: ecd_20201002_models.EncryptPasswordRequest,
|
|
1154
|
+
) -> ecd_20201002_models.EncryptPasswordResponse:
|
|
1155
|
+
"""
|
|
1156
|
+
@param request: EncryptPasswordRequest
|
|
1157
|
+
@return: EncryptPasswordResponse
|
|
1158
|
+
"""
|
|
1159
|
+
runtime = util_models.RuntimeOptions()
|
|
1160
|
+
return self.encrypt_password_with_options(request, runtime)
|
|
1161
|
+
|
|
1162
|
+
async def encrypt_password_async(
|
|
1163
|
+
self,
|
|
1164
|
+
request: ecd_20201002_models.EncryptPasswordRequest,
|
|
1165
|
+
) -> ecd_20201002_models.EncryptPasswordResponse:
|
|
1166
|
+
"""
|
|
1167
|
+
@param request: EncryptPasswordRequest
|
|
1168
|
+
@return: EncryptPasswordResponse
|
|
1169
|
+
"""
|
|
1170
|
+
runtime = util_models.RuntimeOptions()
|
|
1171
|
+
return await self.encrypt_password_with_options_async(request, runtime)
|
|
1172
|
+
|
|
1173
|
+
def get_cloud_drive_service_mount_token_with_options(
|
|
1174
|
+
self,
|
|
1175
|
+
request: ecd_20201002_models.GetCloudDriveServiceMountTokenRequest,
|
|
1176
|
+
runtime: util_models.RuntimeOptions,
|
|
1177
|
+
) -> ecd_20201002_models.GetCloudDriveServiceMountTokenResponse:
|
|
1178
|
+
"""
|
|
1179
|
+
@summary 获取无影云盘的免密token
|
|
1180
|
+
|
|
1181
|
+
@param request: GetCloudDriveServiceMountTokenRequest
|
|
1182
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1183
|
+
@return: GetCloudDriveServiceMountTokenResponse
|
|
1184
|
+
"""
|
|
1185
|
+
UtilClient.validate_model(request)
|
|
1186
|
+
query = {}
|
|
1187
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1188
|
+
query['ClientId'] = request.client_id
|
|
1189
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1190
|
+
query['LoginToken'] = request.login_token
|
|
1191
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1192
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1193
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1194
|
+
query['RegionId'] = request.region_id
|
|
1195
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1196
|
+
query['SessionId'] = request.session_id
|
|
1197
|
+
req = open_api_models.OpenApiRequest(
|
|
1198
|
+
query=OpenApiUtilClient.query(query)
|
|
1199
|
+
)
|
|
1200
|
+
params = open_api_models.Params(
|
|
1201
|
+
action='GetCloudDriveServiceMountToken',
|
|
1202
|
+
version='2020-10-02',
|
|
1203
|
+
protocol='HTTPS',
|
|
1204
|
+
pathname='/',
|
|
1205
|
+
method='POST',
|
|
1206
|
+
auth_type='Anonymous',
|
|
1207
|
+
style='RPC',
|
|
1208
|
+
req_body_type='formData',
|
|
1209
|
+
body_type='json'
|
|
1210
|
+
)
|
|
1211
|
+
return TeaCore.from_map(
|
|
1212
|
+
ecd_20201002_models.GetCloudDriveServiceMountTokenResponse(),
|
|
1213
|
+
self.call_api(params, req, runtime)
|
|
1214
|
+
)
|
|
1215
|
+
|
|
1216
|
+
async def get_cloud_drive_service_mount_token_with_options_async(
|
|
1217
|
+
self,
|
|
1218
|
+
request: ecd_20201002_models.GetCloudDriveServiceMountTokenRequest,
|
|
1219
|
+
runtime: util_models.RuntimeOptions,
|
|
1220
|
+
) -> ecd_20201002_models.GetCloudDriveServiceMountTokenResponse:
|
|
1221
|
+
"""
|
|
1222
|
+
@summary 获取无影云盘的免密token
|
|
1223
|
+
|
|
1224
|
+
@param request: GetCloudDriveServiceMountTokenRequest
|
|
1225
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1226
|
+
@return: GetCloudDriveServiceMountTokenResponse
|
|
1227
|
+
"""
|
|
1228
|
+
UtilClient.validate_model(request)
|
|
1229
|
+
query = {}
|
|
1230
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1231
|
+
query['ClientId'] = request.client_id
|
|
1232
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1233
|
+
query['LoginToken'] = request.login_token
|
|
1234
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1235
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1236
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1237
|
+
query['RegionId'] = request.region_id
|
|
1238
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1239
|
+
query['SessionId'] = request.session_id
|
|
1240
|
+
req = open_api_models.OpenApiRequest(
|
|
1241
|
+
query=OpenApiUtilClient.query(query)
|
|
1242
|
+
)
|
|
1243
|
+
params = open_api_models.Params(
|
|
1244
|
+
action='GetCloudDriveServiceMountToken',
|
|
1245
|
+
version='2020-10-02',
|
|
1246
|
+
protocol='HTTPS',
|
|
1247
|
+
pathname='/',
|
|
1248
|
+
method='POST',
|
|
1249
|
+
auth_type='Anonymous',
|
|
1250
|
+
style='RPC',
|
|
1251
|
+
req_body_type='formData',
|
|
1252
|
+
body_type='json'
|
|
1253
|
+
)
|
|
1254
|
+
return TeaCore.from_map(
|
|
1255
|
+
ecd_20201002_models.GetCloudDriveServiceMountTokenResponse(),
|
|
1256
|
+
await self.call_api_async(params, req, runtime)
|
|
1257
|
+
)
|
|
1258
|
+
|
|
1259
|
+
def get_cloud_drive_service_mount_token(
|
|
1260
|
+
self,
|
|
1261
|
+
request: ecd_20201002_models.GetCloudDriveServiceMountTokenRequest,
|
|
1262
|
+
) -> ecd_20201002_models.GetCloudDriveServiceMountTokenResponse:
|
|
1263
|
+
"""
|
|
1264
|
+
@summary 获取无影云盘的免密token
|
|
1265
|
+
|
|
1266
|
+
@param request: GetCloudDriveServiceMountTokenRequest
|
|
1267
|
+
@return: GetCloudDriveServiceMountTokenResponse
|
|
1268
|
+
"""
|
|
1269
|
+
runtime = util_models.RuntimeOptions()
|
|
1270
|
+
return self.get_cloud_drive_service_mount_token_with_options(request, runtime)
|
|
1271
|
+
|
|
1272
|
+
async def get_cloud_drive_service_mount_token_async(
|
|
1273
|
+
self,
|
|
1274
|
+
request: ecd_20201002_models.GetCloudDriveServiceMountTokenRequest,
|
|
1275
|
+
) -> ecd_20201002_models.GetCloudDriveServiceMountTokenResponse:
|
|
1276
|
+
"""
|
|
1277
|
+
@summary 获取无影云盘的免密token
|
|
1278
|
+
|
|
1279
|
+
@param request: GetCloudDriveServiceMountTokenRequest
|
|
1280
|
+
@return: GetCloudDriveServiceMountTokenResponse
|
|
1281
|
+
"""
|
|
1282
|
+
runtime = util_models.RuntimeOptions()
|
|
1283
|
+
return await self.get_cloud_drive_service_mount_token_with_options_async(request, runtime)
|
|
1284
|
+
|
|
1285
|
+
def get_connection_ticket_with_options(
|
|
1286
|
+
self,
|
|
1287
|
+
request: ecd_20201002_models.GetConnectionTicketRequest,
|
|
1288
|
+
runtime: util_models.RuntimeOptions,
|
|
1289
|
+
) -> ecd_20201002_models.GetConnectionTicketResponse:
|
|
1290
|
+
"""
|
|
1291
|
+
@param request: GetConnectionTicketRequest
|
|
1292
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1293
|
+
@return: GetConnectionTicketResponse
|
|
1294
|
+
"""
|
|
1295
|
+
UtilClient.validate_model(request)
|
|
1296
|
+
query = {}
|
|
1297
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1298
|
+
query['ClientId'] = request.client_id
|
|
1299
|
+
if not UtilClient.is_unset(request.client_os):
|
|
1300
|
+
query['ClientOS'] = request.client_os
|
|
1301
|
+
if not UtilClient.is_unset(request.client_type):
|
|
1302
|
+
query['ClientType'] = request.client_type
|
|
1303
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1304
|
+
query['ClientVersion'] = request.client_version
|
|
1305
|
+
if not UtilClient.is_unset(request.command_content):
|
|
1306
|
+
query['CommandContent'] = request.command_content
|
|
1307
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1308
|
+
query['DesktopId'] = request.desktop_id
|
|
1309
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1310
|
+
query['LoginToken'] = request.login_token
|
|
1311
|
+
if not UtilClient.is_unset(request.owner_id):
|
|
1312
|
+
query['OwnerId'] = request.owner_id
|
|
1313
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1314
|
+
query['RegionId'] = request.region_id
|
|
1315
|
+
if not UtilClient.is_unset(request.resource_owner_account):
|
|
1316
|
+
query['ResourceOwnerAccount'] = request.resource_owner_account
|
|
1317
|
+
if not UtilClient.is_unset(request.resource_owner_id):
|
|
1318
|
+
query['ResourceOwnerId'] = request.resource_owner_id
|
|
1319
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1320
|
+
query['SessionId'] = request.session_id
|
|
1321
|
+
if not UtilClient.is_unset(request.tag):
|
|
1322
|
+
query['Tag'] = request.tag
|
|
1323
|
+
if not UtilClient.is_unset(request.task_id):
|
|
1324
|
+
query['TaskId'] = request.task_id
|
|
1325
|
+
if not UtilClient.is_unset(request.uuid):
|
|
1326
|
+
query['Uuid'] = request.uuid
|
|
1327
|
+
req = open_api_models.OpenApiRequest(
|
|
1328
|
+
query=OpenApiUtilClient.query(query)
|
|
1329
|
+
)
|
|
1330
|
+
params = open_api_models.Params(
|
|
1331
|
+
action='GetConnectionTicket',
|
|
1332
|
+
version='2020-10-02',
|
|
1333
|
+
protocol='HTTPS',
|
|
1334
|
+
pathname='/',
|
|
1335
|
+
method='POST',
|
|
1336
|
+
auth_type='Anonymous',
|
|
1337
|
+
style='RPC',
|
|
1338
|
+
req_body_type='formData',
|
|
1339
|
+
body_type='json'
|
|
1340
|
+
)
|
|
1341
|
+
return TeaCore.from_map(
|
|
1342
|
+
ecd_20201002_models.GetConnectionTicketResponse(),
|
|
1343
|
+
self.call_api(params, req, runtime)
|
|
1344
|
+
)
|
|
1345
|
+
|
|
1346
|
+
async def get_connection_ticket_with_options_async(
|
|
1347
|
+
self,
|
|
1348
|
+
request: ecd_20201002_models.GetConnectionTicketRequest,
|
|
1349
|
+
runtime: util_models.RuntimeOptions,
|
|
1350
|
+
) -> ecd_20201002_models.GetConnectionTicketResponse:
|
|
1351
|
+
"""
|
|
1352
|
+
@param request: GetConnectionTicketRequest
|
|
1353
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1354
|
+
@return: GetConnectionTicketResponse
|
|
1355
|
+
"""
|
|
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.client_os):
|
|
1361
|
+
query['ClientOS'] = request.client_os
|
|
1362
|
+
if not UtilClient.is_unset(request.client_type):
|
|
1363
|
+
query['ClientType'] = request.client_type
|
|
1364
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1365
|
+
query['ClientVersion'] = request.client_version
|
|
1366
|
+
if not UtilClient.is_unset(request.command_content):
|
|
1367
|
+
query['CommandContent'] = request.command_content
|
|
1368
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1369
|
+
query['DesktopId'] = request.desktop_id
|
|
1370
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1371
|
+
query['LoginToken'] = request.login_token
|
|
1372
|
+
if not UtilClient.is_unset(request.owner_id):
|
|
1373
|
+
query['OwnerId'] = request.owner_id
|
|
1374
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1375
|
+
query['RegionId'] = request.region_id
|
|
1376
|
+
if not UtilClient.is_unset(request.resource_owner_account):
|
|
1377
|
+
query['ResourceOwnerAccount'] = request.resource_owner_account
|
|
1378
|
+
if not UtilClient.is_unset(request.resource_owner_id):
|
|
1379
|
+
query['ResourceOwnerId'] = request.resource_owner_id
|
|
1380
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1381
|
+
query['SessionId'] = request.session_id
|
|
1382
|
+
if not UtilClient.is_unset(request.tag):
|
|
1383
|
+
query['Tag'] = request.tag
|
|
1384
|
+
if not UtilClient.is_unset(request.task_id):
|
|
1385
|
+
query['TaskId'] = request.task_id
|
|
1386
|
+
if not UtilClient.is_unset(request.uuid):
|
|
1387
|
+
query['Uuid'] = request.uuid
|
|
1388
|
+
req = open_api_models.OpenApiRequest(
|
|
1389
|
+
query=OpenApiUtilClient.query(query)
|
|
1390
|
+
)
|
|
1391
|
+
params = open_api_models.Params(
|
|
1392
|
+
action='GetConnectionTicket',
|
|
1393
|
+
version='2020-10-02',
|
|
1394
|
+
protocol='HTTPS',
|
|
1395
|
+
pathname='/',
|
|
1396
|
+
method='POST',
|
|
1397
|
+
auth_type='Anonymous',
|
|
1398
|
+
style='RPC',
|
|
1399
|
+
req_body_type='formData',
|
|
1400
|
+
body_type='json'
|
|
1401
|
+
)
|
|
1402
|
+
return TeaCore.from_map(
|
|
1403
|
+
ecd_20201002_models.GetConnectionTicketResponse(),
|
|
1404
|
+
await self.call_api_async(params, req, runtime)
|
|
1405
|
+
)
|
|
1406
|
+
|
|
1407
|
+
def get_connection_ticket(
|
|
1408
|
+
self,
|
|
1409
|
+
request: ecd_20201002_models.GetConnectionTicketRequest,
|
|
1410
|
+
) -> ecd_20201002_models.GetConnectionTicketResponse:
|
|
1411
|
+
"""
|
|
1412
|
+
@param request: GetConnectionTicketRequest
|
|
1413
|
+
@return: GetConnectionTicketResponse
|
|
1414
|
+
"""
|
|
1415
|
+
runtime = util_models.RuntimeOptions()
|
|
1416
|
+
return self.get_connection_ticket_with_options(request, runtime)
|
|
1417
|
+
|
|
1418
|
+
async def get_connection_ticket_async(
|
|
1419
|
+
self,
|
|
1420
|
+
request: ecd_20201002_models.GetConnectionTicketRequest,
|
|
1421
|
+
) -> ecd_20201002_models.GetConnectionTicketResponse:
|
|
1422
|
+
"""
|
|
1423
|
+
@param request: GetConnectionTicketRequest
|
|
1424
|
+
@return: GetConnectionTicketResponse
|
|
1425
|
+
"""
|
|
1426
|
+
runtime = util_models.RuntimeOptions()
|
|
1427
|
+
return await self.get_connection_ticket_with_options_async(request, runtime)
|
|
1428
|
+
|
|
1429
|
+
def get_login_token_with_options(
|
|
1430
|
+
self,
|
|
1431
|
+
request: ecd_20201002_models.GetLoginTokenRequest,
|
|
1432
|
+
runtime: util_models.RuntimeOptions,
|
|
1433
|
+
) -> ecd_20201002_models.GetLoginTokenResponse:
|
|
1434
|
+
"""
|
|
1435
|
+
@summary Obtains logon credentials.
|
|
1436
|
+
|
|
1437
|
+
@param request: GetLoginTokenRequest
|
|
1438
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1439
|
+
@return: GetLoginTokenResponse
|
|
1440
|
+
"""
|
|
1441
|
+
UtilClient.validate_model(request)
|
|
1442
|
+
query = {}
|
|
1443
|
+
if not UtilClient.is_unset(request.authentication_code):
|
|
1444
|
+
query['AuthenticationCode'] = request.authentication_code
|
|
1445
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1446
|
+
query['ClientId'] = request.client_id
|
|
1447
|
+
if not UtilClient.is_unset(request.client_os):
|
|
1448
|
+
query['ClientOS'] = request.client_os
|
|
1449
|
+
if not UtilClient.is_unset(request.client_type):
|
|
1450
|
+
query['ClientType'] = request.client_type
|
|
1451
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1452
|
+
query['ClientVersion'] = request.client_version
|
|
1453
|
+
if not UtilClient.is_unset(request.current_stage):
|
|
1454
|
+
query['CurrentStage'] = request.current_stage
|
|
1455
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
1456
|
+
query['DirectoryId'] = request.directory_id
|
|
1457
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1458
|
+
query['EndUserId'] = request.end_user_id
|
|
1459
|
+
if not UtilClient.is_unset(request.keep_alive):
|
|
1460
|
+
query['KeepAlive'] = request.keep_alive
|
|
1461
|
+
if not UtilClient.is_unset(request.keep_alive_token):
|
|
1462
|
+
query['KeepAliveToken'] = request.keep_alive_token
|
|
1463
|
+
if not UtilClient.is_unset(request.new_password):
|
|
1464
|
+
query['NewPassword'] = request.new_password
|
|
1465
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1466
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1467
|
+
if not UtilClient.is_unset(request.old_password):
|
|
1468
|
+
query['OldPassword'] = request.old_password
|
|
1469
|
+
if not UtilClient.is_unset(request.password):
|
|
1470
|
+
query['Password'] = request.password
|
|
1471
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1472
|
+
query['RegionId'] = request.region_id
|
|
1473
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1474
|
+
query['SessionId'] = request.session_id
|
|
1475
|
+
if not UtilClient.is_unset(request.token_code):
|
|
1476
|
+
query['TokenCode'] = request.token_code
|
|
1477
|
+
if not UtilClient.is_unset(request.uuid):
|
|
1478
|
+
query['Uuid'] = request.uuid
|
|
1479
|
+
req = open_api_models.OpenApiRequest(
|
|
1480
|
+
query=OpenApiUtilClient.query(query)
|
|
1481
|
+
)
|
|
1482
|
+
params = open_api_models.Params(
|
|
1483
|
+
action='GetLoginToken',
|
|
1484
|
+
version='2020-10-02',
|
|
1485
|
+
protocol='HTTPS',
|
|
1486
|
+
pathname='/',
|
|
1487
|
+
method='POST',
|
|
1488
|
+
auth_type='Anonymous',
|
|
1489
|
+
style='RPC',
|
|
1490
|
+
req_body_type='formData',
|
|
1491
|
+
body_type='json'
|
|
1492
|
+
)
|
|
1493
|
+
return TeaCore.from_map(
|
|
1494
|
+
ecd_20201002_models.GetLoginTokenResponse(),
|
|
1495
|
+
self.call_api(params, req, runtime)
|
|
1496
|
+
)
|
|
1497
|
+
|
|
1498
|
+
async def get_login_token_with_options_async(
|
|
1499
|
+
self,
|
|
1500
|
+
request: ecd_20201002_models.GetLoginTokenRequest,
|
|
1501
|
+
runtime: util_models.RuntimeOptions,
|
|
1502
|
+
) -> ecd_20201002_models.GetLoginTokenResponse:
|
|
1503
|
+
"""
|
|
1504
|
+
@summary Obtains logon credentials.
|
|
1505
|
+
|
|
1506
|
+
@param request: GetLoginTokenRequest
|
|
1507
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1508
|
+
@return: GetLoginTokenResponse
|
|
1509
|
+
"""
|
|
1510
|
+
UtilClient.validate_model(request)
|
|
1511
|
+
query = {}
|
|
1512
|
+
if not UtilClient.is_unset(request.authentication_code):
|
|
1513
|
+
query['AuthenticationCode'] = request.authentication_code
|
|
1514
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1515
|
+
query['ClientId'] = request.client_id
|
|
1516
|
+
if not UtilClient.is_unset(request.client_os):
|
|
1517
|
+
query['ClientOS'] = request.client_os
|
|
1518
|
+
if not UtilClient.is_unset(request.client_type):
|
|
1519
|
+
query['ClientType'] = request.client_type
|
|
1520
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1521
|
+
query['ClientVersion'] = request.client_version
|
|
1522
|
+
if not UtilClient.is_unset(request.current_stage):
|
|
1523
|
+
query['CurrentStage'] = request.current_stage
|
|
1524
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
1525
|
+
query['DirectoryId'] = request.directory_id
|
|
1526
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1527
|
+
query['EndUserId'] = request.end_user_id
|
|
1528
|
+
if not UtilClient.is_unset(request.keep_alive):
|
|
1529
|
+
query['KeepAlive'] = request.keep_alive
|
|
1530
|
+
if not UtilClient.is_unset(request.keep_alive_token):
|
|
1531
|
+
query['KeepAliveToken'] = request.keep_alive_token
|
|
1532
|
+
if not UtilClient.is_unset(request.new_password):
|
|
1533
|
+
query['NewPassword'] = request.new_password
|
|
1534
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1535
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1536
|
+
if not UtilClient.is_unset(request.old_password):
|
|
1537
|
+
query['OldPassword'] = request.old_password
|
|
1538
|
+
if not UtilClient.is_unset(request.password):
|
|
1539
|
+
query['Password'] = request.password
|
|
1540
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1541
|
+
query['RegionId'] = request.region_id
|
|
1542
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1543
|
+
query['SessionId'] = request.session_id
|
|
1544
|
+
if not UtilClient.is_unset(request.token_code):
|
|
1545
|
+
query['TokenCode'] = request.token_code
|
|
1546
|
+
if not UtilClient.is_unset(request.uuid):
|
|
1547
|
+
query['Uuid'] = request.uuid
|
|
1548
|
+
req = open_api_models.OpenApiRequest(
|
|
1549
|
+
query=OpenApiUtilClient.query(query)
|
|
1550
|
+
)
|
|
1551
|
+
params = open_api_models.Params(
|
|
1552
|
+
action='GetLoginToken',
|
|
1553
|
+
version='2020-10-02',
|
|
1554
|
+
protocol='HTTPS',
|
|
1555
|
+
pathname='/',
|
|
1556
|
+
method='POST',
|
|
1557
|
+
auth_type='Anonymous',
|
|
1558
|
+
style='RPC',
|
|
1559
|
+
req_body_type='formData',
|
|
1560
|
+
body_type='json'
|
|
1561
|
+
)
|
|
1562
|
+
return TeaCore.from_map(
|
|
1563
|
+
ecd_20201002_models.GetLoginTokenResponse(),
|
|
1564
|
+
await self.call_api_async(params, req, runtime)
|
|
1565
|
+
)
|
|
1566
|
+
|
|
1567
|
+
def get_login_token(
|
|
1568
|
+
self,
|
|
1569
|
+
request: ecd_20201002_models.GetLoginTokenRequest,
|
|
1570
|
+
) -> ecd_20201002_models.GetLoginTokenResponse:
|
|
1571
|
+
"""
|
|
1572
|
+
@summary Obtains logon credentials.
|
|
1573
|
+
|
|
1574
|
+
@param request: GetLoginTokenRequest
|
|
1575
|
+
@return: GetLoginTokenResponse
|
|
1576
|
+
"""
|
|
1577
|
+
runtime = util_models.RuntimeOptions()
|
|
1578
|
+
return self.get_login_token_with_options(request, runtime)
|
|
1579
|
+
|
|
1580
|
+
async def get_login_token_async(
|
|
1581
|
+
self,
|
|
1582
|
+
request: ecd_20201002_models.GetLoginTokenRequest,
|
|
1583
|
+
) -> ecd_20201002_models.GetLoginTokenResponse:
|
|
1584
|
+
"""
|
|
1585
|
+
@summary Obtains logon credentials.
|
|
1586
|
+
|
|
1587
|
+
@param request: GetLoginTokenRequest
|
|
1588
|
+
@return: GetLoginTokenResponse
|
|
1589
|
+
"""
|
|
1590
|
+
runtime = util_models.RuntimeOptions()
|
|
1591
|
+
return await self.get_login_token_with_options_async(request, runtime)
|
|
1592
|
+
|
|
1593
|
+
def is_keep_alive_with_options(
|
|
1594
|
+
self,
|
|
1595
|
+
request: ecd_20201002_models.IsKeepAliveRequest,
|
|
1596
|
+
runtime: util_models.RuntimeOptions,
|
|
1597
|
+
) -> ecd_20201002_models.IsKeepAliveResponse:
|
|
1598
|
+
"""
|
|
1599
|
+
@summary 是否保持登录判断接口
|
|
1600
|
+
|
|
1601
|
+
@param request: IsKeepAliveRequest
|
|
1602
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1603
|
+
@return: IsKeepAliveResponse
|
|
1604
|
+
"""
|
|
1605
|
+
UtilClient.validate_model(request)
|
|
1606
|
+
query = {}
|
|
1607
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1608
|
+
query['ClientId'] = request.client_id
|
|
1609
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1610
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1611
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1612
|
+
query['RegionId'] = request.region_id
|
|
1613
|
+
req = open_api_models.OpenApiRequest(
|
|
1614
|
+
query=OpenApiUtilClient.query(query)
|
|
1615
|
+
)
|
|
1616
|
+
params = open_api_models.Params(
|
|
1617
|
+
action='IsKeepAlive',
|
|
1618
|
+
version='2020-10-02',
|
|
1619
|
+
protocol='HTTPS',
|
|
1620
|
+
pathname='/',
|
|
1621
|
+
method='POST',
|
|
1622
|
+
auth_type='Anonymous',
|
|
1623
|
+
style='RPC',
|
|
1624
|
+
req_body_type='formData',
|
|
1625
|
+
body_type='json'
|
|
1626
|
+
)
|
|
1627
|
+
return TeaCore.from_map(
|
|
1628
|
+
ecd_20201002_models.IsKeepAliveResponse(),
|
|
1629
|
+
self.call_api(params, req, runtime)
|
|
1630
|
+
)
|
|
1631
|
+
|
|
1632
|
+
async def is_keep_alive_with_options_async(
|
|
1633
|
+
self,
|
|
1634
|
+
request: ecd_20201002_models.IsKeepAliveRequest,
|
|
1635
|
+
runtime: util_models.RuntimeOptions,
|
|
1636
|
+
) -> ecd_20201002_models.IsKeepAliveResponse:
|
|
1637
|
+
"""
|
|
1638
|
+
@summary 是否保持登录判断接口
|
|
1639
|
+
|
|
1640
|
+
@param request: IsKeepAliveRequest
|
|
1641
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1642
|
+
@return: IsKeepAliveResponse
|
|
1643
|
+
"""
|
|
1644
|
+
UtilClient.validate_model(request)
|
|
1645
|
+
query = {}
|
|
1646
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1647
|
+
query['ClientId'] = request.client_id
|
|
1648
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1649
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1650
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1651
|
+
query['RegionId'] = request.region_id
|
|
1652
|
+
req = open_api_models.OpenApiRequest(
|
|
1653
|
+
query=OpenApiUtilClient.query(query)
|
|
1654
|
+
)
|
|
1655
|
+
params = open_api_models.Params(
|
|
1656
|
+
action='IsKeepAlive',
|
|
1657
|
+
version='2020-10-02',
|
|
1658
|
+
protocol='HTTPS',
|
|
1659
|
+
pathname='/',
|
|
1660
|
+
method='POST',
|
|
1661
|
+
auth_type='Anonymous',
|
|
1662
|
+
style='RPC',
|
|
1663
|
+
req_body_type='formData',
|
|
1664
|
+
body_type='json'
|
|
1665
|
+
)
|
|
1666
|
+
return TeaCore.from_map(
|
|
1667
|
+
ecd_20201002_models.IsKeepAliveResponse(),
|
|
1668
|
+
await self.call_api_async(params, req, runtime)
|
|
1669
|
+
)
|
|
1670
|
+
|
|
1671
|
+
def is_keep_alive(
|
|
1672
|
+
self,
|
|
1673
|
+
request: ecd_20201002_models.IsKeepAliveRequest,
|
|
1674
|
+
) -> ecd_20201002_models.IsKeepAliveResponse:
|
|
1675
|
+
"""
|
|
1676
|
+
@summary 是否保持登录判断接口
|
|
1677
|
+
|
|
1678
|
+
@param request: IsKeepAliveRequest
|
|
1679
|
+
@return: IsKeepAliveResponse
|
|
1680
|
+
"""
|
|
1681
|
+
runtime = util_models.RuntimeOptions()
|
|
1682
|
+
return self.is_keep_alive_with_options(request, runtime)
|
|
1683
|
+
|
|
1684
|
+
async def is_keep_alive_async(
|
|
1685
|
+
self,
|
|
1686
|
+
request: ecd_20201002_models.IsKeepAliveRequest,
|
|
1687
|
+
) -> ecd_20201002_models.IsKeepAliveResponse:
|
|
1688
|
+
"""
|
|
1689
|
+
@summary 是否保持登录判断接口
|
|
1690
|
+
|
|
1691
|
+
@param request: IsKeepAliveRequest
|
|
1692
|
+
@return: IsKeepAliveResponse
|
|
1693
|
+
"""
|
|
1694
|
+
runtime = util_models.RuntimeOptions()
|
|
1695
|
+
return await self.is_keep_alive_with_options_async(request, runtime)
|
|
1696
|
+
|
|
1697
|
+
def query_eds_agent_report_config_with_options(
|
|
1698
|
+
self,
|
|
1699
|
+
request: ecd_20201002_models.QueryEdsAgentReportConfigRequest,
|
|
1700
|
+
runtime: util_models.RuntimeOptions,
|
|
1701
|
+
) -> ecd_20201002_models.QueryEdsAgentReportConfigResponse:
|
|
1702
|
+
"""
|
|
1703
|
+
@summary 查询Agent需要上报的配置信息
|
|
1704
|
+
|
|
1705
|
+
@param request: QueryEdsAgentReportConfigRequest
|
|
1706
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1707
|
+
@return: QueryEdsAgentReportConfigResponse
|
|
1708
|
+
"""
|
|
1709
|
+
UtilClient.validate_model(request)
|
|
1710
|
+
query = {}
|
|
1711
|
+
if not UtilClient.is_unset(request.ali_uid):
|
|
1712
|
+
query['AliUid'] = request.ali_uid
|
|
1713
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1714
|
+
query['DesktopId'] = request.desktop_id
|
|
1715
|
+
if not UtilClient.is_unset(request.ecs_instance_id):
|
|
1716
|
+
query['EcsInstanceId'] = request.ecs_instance_id
|
|
1717
|
+
req = open_api_models.OpenApiRequest(
|
|
1718
|
+
query=OpenApiUtilClient.query(query)
|
|
1719
|
+
)
|
|
1720
|
+
params = open_api_models.Params(
|
|
1721
|
+
action='QueryEdsAgentReportConfig',
|
|
1722
|
+
version='2020-10-02',
|
|
1723
|
+
protocol='HTTPS',
|
|
1724
|
+
pathname='/',
|
|
1725
|
+
method='POST',
|
|
1726
|
+
auth_type='Anonymous',
|
|
1727
|
+
style='RPC',
|
|
1728
|
+
req_body_type='formData',
|
|
1729
|
+
body_type='json'
|
|
1730
|
+
)
|
|
1731
|
+
return TeaCore.from_map(
|
|
1732
|
+
ecd_20201002_models.QueryEdsAgentReportConfigResponse(),
|
|
1733
|
+
self.call_api(params, req, runtime)
|
|
1734
|
+
)
|
|
1735
|
+
|
|
1736
|
+
async def query_eds_agent_report_config_with_options_async(
|
|
1737
|
+
self,
|
|
1738
|
+
request: ecd_20201002_models.QueryEdsAgentReportConfigRequest,
|
|
1739
|
+
runtime: util_models.RuntimeOptions,
|
|
1740
|
+
) -> ecd_20201002_models.QueryEdsAgentReportConfigResponse:
|
|
1741
|
+
"""
|
|
1742
|
+
@summary 查询Agent需要上报的配置信息
|
|
1743
|
+
|
|
1744
|
+
@param request: QueryEdsAgentReportConfigRequest
|
|
1745
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1746
|
+
@return: QueryEdsAgentReportConfigResponse
|
|
1747
|
+
"""
|
|
1748
|
+
UtilClient.validate_model(request)
|
|
1749
|
+
query = {}
|
|
1750
|
+
if not UtilClient.is_unset(request.ali_uid):
|
|
1751
|
+
query['AliUid'] = request.ali_uid
|
|
1752
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1753
|
+
query['DesktopId'] = request.desktop_id
|
|
1754
|
+
if not UtilClient.is_unset(request.ecs_instance_id):
|
|
1755
|
+
query['EcsInstanceId'] = request.ecs_instance_id
|
|
1756
|
+
req = open_api_models.OpenApiRequest(
|
|
1757
|
+
query=OpenApiUtilClient.query(query)
|
|
1758
|
+
)
|
|
1759
|
+
params = open_api_models.Params(
|
|
1760
|
+
action='QueryEdsAgentReportConfig',
|
|
1761
|
+
version='2020-10-02',
|
|
1762
|
+
protocol='HTTPS',
|
|
1763
|
+
pathname='/',
|
|
1764
|
+
method='POST',
|
|
1765
|
+
auth_type='Anonymous',
|
|
1766
|
+
style='RPC',
|
|
1767
|
+
req_body_type='formData',
|
|
1768
|
+
body_type='json'
|
|
1769
|
+
)
|
|
1770
|
+
return TeaCore.from_map(
|
|
1771
|
+
ecd_20201002_models.QueryEdsAgentReportConfigResponse(),
|
|
1772
|
+
await self.call_api_async(params, req, runtime)
|
|
1773
|
+
)
|
|
1774
|
+
|
|
1775
|
+
def query_eds_agent_report_config(
|
|
1776
|
+
self,
|
|
1777
|
+
request: ecd_20201002_models.QueryEdsAgentReportConfigRequest,
|
|
1778
|
+
) -> ecd_20201002_models.QueryEdsAgentReportConfigResponse:
|
|
1779
|
+
"""
|
|
1780
|
+
@summary 查询Agent需要上报的配置信息
|
|
1781
|
+
|
|
1782
|
+
@param request: QueryEdsAgentReportConfigRequest
|
|
1783
|
+
@return: QueryEdsAgentReportConfigResponse
|
|
1784
|
+
"""
|
|
1785
|
+
runtime = util_models.RuntimeOptions()
|
|
1786
|
+
return self.query_eds_agent_report_config_with_options(request, runtime)
|
|
1787
|
+
|
|
1788
|
+
async def query_eds_agent_report_config_async(
|
|
1789
|
+
self,
|
|
1790
|
+
request: ecd_20201002_models.QueryEdsAgentReportConfigRequest,
|
|
1791
|
+
) -> ecd_20201002_models.QueryEdsAgentReportConfigResponse:
|
|
1792
|
+
"""
|
|
1793
|
+
@summary 查询Agent需要上报的配置信息
|
|
1794
|
+
|
|
1795
|
+
@param request: QueryEdsAgentReportConfigRequest
|
|
1796
|
+
@return: QueryEdsAgentReportConfigResponse
|
|
1797
|
+
"""
|
|
1798
|
+
runtime = util_models.RuntimeOptions()
|
|
1799
|
+
return await self.query_eds_agent_report_config_with_options_async(request, runtime)
|
|
1800
|
+
|
|
1801
|
+
def reboot_desktops_with_options(
|
|
1802
|
+
self,
|
|
1803
|
+
request: ecd_20201002_models.RebootDesktopsRequest,
|
|
1804
|
+
runtime: util_models.RuntimeOptions,
|
|
1805
|
+
) -> ecd_20201002_models.RebootDesktopsResponse:
|
|
1806
|
+
"""
|
|
1807
|
+
@summary Restart cloud computers.
|
|
1808
|
+
|
|
1809
|
+
@param request: RebootDesktopsRequest
|
|
1810
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1811
|
+
@return: RebootDesktopsResponse
|
|
1812
|
+
"""
|
|
1813
|
+
UtilClient.validate_model(request)
|
|
1814
|
+
query = {}
|
|
1815
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1816
|
+
query['ClientId'] = request.client_id
|
|
1817
|
+
if not UtilClient.is_unset(request.client_os):
|
|
1818
|
+
query['ClientOS'] = request.client_os
|
|
1819
|
+
if not UtilClient.is_unset(request.client_token):
|
|
1820
|
+
query['ClientToken'] = request.client_token
|
|
1821
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1822
|
+
query['ClientVersion'] = request.client_version
|
|
1823
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1824
|
+
query['DesktopId'] = request.desktop_id
|
|
1825
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1826
|
+
query['LoginToken'] = request.login_token
|
|
1827
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1828
|
+
query['RegionId'] = request.region_id
|
|
1829
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1830
|
+
query['SessionId'] = request.session_id
|
|
1831
|
+
if not UtilClient.is_unset(request.session_token):
|
|
1832
|
+
query['SessionToken'] = request.session_token
|
|
1833
|
+
if not UtilClient.is_unset(request.uuid):
|
|
1834
|
+
query['Uuid'] = request.uuid
|
|
1835
|
+
req = open_api_models.OpenApiRequest(
|
|
1836
|
+
query=OpenApiUtilClient.query(query)
|
|
1837
|
+
)
|
|
1838
|
+
params = open_api_models.Params(
|
|
1839
|
+
action='RebootDesktops',
|
|
1840
|
+
version='2020-10-02',
|
|
1841
|
+
protocol='HTTPS',
|
|
1842
|
+
pathname='/',
|
|
1843
|
+
method='POST',
|
|
1844
|
+
auth_type='Anonymous',
|
|
1845
|
+
style='RPC',
|
|
1846
|
+
req_body_type='formData',
|
|
1847
|
+
body_type='json'
|
|
1848
|
+
)
|
|
1849
|
+
return TeaCore.from_map(
|
|
1850
|
+
ecd_20201002_models.RebootDesktopsResponse(),
|
|
1851
|
+
self.call_api(params, req, runtime)
|
|
1852
|
+
)
|
|
1853
|
+
|
|
1854
|
+
async def reboot_desktops_with_options_async(
|
|
1855
|
+
self,
|
|
1856
|
+
request: ecd_20201002_models.RebootDesktopsRequest,
|
|
1857
|
+
runtime: util_models.RuntimeOptions,
|
|
1858
|
+
) -> ecd_20201002_models.RebootDesktopsResponse:
|
|
1859
|
+
"""
|
|
1860
|
+
@summary Restart cloud computers.
|
|
1861
|
+
|
|
1862
|
+
@param request: RebootDesktopsRequest
|
|
1863
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1864
|
+
@return: RebootDesktopsResponse
|
|
1865
|
+
"""
|
|
1866
|
+
UtilClient.validate_model(request)
|
|
1867
|
+
query = {}
|
|
1868
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1869
|
+
query['ClientId'] = request.client_id
|
|
1870
|
+
if not UtilClient.is_unset(request.client_os):
|
|
1871
|
+
query['ClientOS'] = request.client_os
|
|
1872
|
+
if not UtilClient.is_unset(request.client_token):
|
|
1873
|
+
query['ClientToken'] = request.client_token
|
|
1874
|
+
if not UtilClient.is_unset(request.client_version):
|
|
1875
|
+
query['ClientVersion'] = request.client_version
|
|
1876
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
1877
|
+
query['DesktopId'] = request.desktop_id
|
|
1878
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1879
|
+
query['LoginToken'] = request.login_token
|
|
1880
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1881
|
+
query['RegionId'] = request.region_id
|
|
1882
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1883
|
+
query['SessionId'] = request.session_id
|
|
1884
|
+
if not UtilClient.is_unset(request.session_token):
|
|
1885
|
+
query['SessionToken'] = request.session_token
|
|
1886
|
+
if not UtilClient.is_unset(request.uuid):
|
|
1887
|
+
query['Uuid'] = request.uuid
|
|
1888
|
+
req = open_api_models.OpenApiRequest(
|
|
1889
|
+
query=OpenApiUtilClient.query(query)
|
|
1890
|
+
)
|
|
1891
|
+
params = open_api_models.Params(
|
|
1892
|
+
action='RebootDesktops',
|
|
1893
|
+
version='2020-10-02',
|
|
1894
|
+
protocol='HTTPS',
|
|
1895
|
+
pathname='/',
|
|
1896
|
+
method='POST',
|
|
1897
|
+
auth_type='Anonymous',
|
|
1898
|
+
style='RPC',
|
|
1899
|
+
req_body_type='formData',
|
|
1900
|
+
body_type='json'
|
|
1901
|
+
)
|
|
1902
|
+
return TeaCore.from_map(
|
|
1903
|
+
ecd_20201002_models.RebootDesktopsResponse(),
|
|
1904
|
+
await self.call_api_async(params, req, runtime)
|
|
1905
|
+
)
|
|
1906
|
+
|
|
1907
|
+
def reboot_desktops(
|
|
1908
|
+
self,
|
|
1909
|
+
request: ecd_20201002_models.RebootDesktopsRequest,
|
|
1910
|
+
) -> ecd_20201002_models.RebootDesktopsResponse:
|
|
1911
|
+
"""
|
|
1912
|
+
@summary Restart cloud computers.
|
|
1913
|
+
|
|
1914
|
+
@param request: RebootDesktopsRequest
|
|
1915
|
+
@return: RebootDesktopsResponse
|
|
1916
|
+
"""
|
|
1917
|
+
runtime = util_models.RuntimeOptions()
|
|
1918
|
+
return self.reboot_desktops_with_options(request, runtime)
|
|
1919
|
+
|
|
1920
|
+
async def reboot_desktops_async(
|
|
1921
|
+
self,
|
|
1922
|
+
request: ecd_20201002_models.RebootDesktopsRequest,
|
|
1923
|
+
) -> ecd_20201002_models.RebootDesktopsResponse:
|
|
1924
|
+
"""
|
|
1925
|
+
@summary Restart cloud computers.
|
|
1926
|
+
|
|
1927
|
+
@param request: RebootDesktopsRequest
|
|
1928
|
+
@return: RebootDesktopsResponse
|
|
1929
|
+
"""
|
|
1930
|
+
runtime = util_models.RuntimeOptions()
|
|
1931
|
+
return await self.reboot_desktops_with_options_async(request, runtime)
|
|
1932
|
+
|
|
1933
|
+
def refresh_login_token_with_options(
|
|
1934
|
+
self,
|
|
1935
|
+
request: ecd_20201002_models.RefreshLoginTokenRequest,
|
|
1936
|
+
runtime: util_models.RuntimeOptions,
|
|
1937
|
+
) -> ecd_20201002_models.RefreshLoginTokenResponse:
|
|
1938
|
+
"""
|
|
1939
|
+
@param request: RefreshLoginTokenRequest
|
|
1940
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1941
|
+
@return: RefreshLoginTokenResponse
|
|
1942
|
+
"""
|
|
1943
|
+
UtilClient.validate_model(request)
|
|
1944
|
+
query = {}
|
|
1945
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1946
|
+
query['ClientId'] = request.client_id
|
|
1947
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
1948
|
+
query['DirectoryId'] = request.directory_id
|
|
1949
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1950
|
+
query['EndUserId'] = request.end_user_id
|
|
1951
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1952
|
+
query['LoginToken'] = request.login_token
|
|
1953
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1954
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
1955
|
+
if not UtilClient.is_unset(request.region_id):
|
|
1956
|
+
query['RegionId'] = request.region_id
|
|
1957
|
+
if not UtilClient.is_unset(request.session_id):
|
|
1958
|
+
query['SessionId'] = request.session_id
|
|
1959
|
+
req = open_api_models.OpenApiRequest(
|
|
1960
|
+
query=OpenApiUtilClient.query(query)
|
|
1961
|
+
)
|
|
1962
|
+
params = open_api_models.Params(
|
|
1963
|
+
action='RefreshLoginToken',
|
|
1964
|
+
version='2020-10-02',
|
|
1965
|
+
protocol='HTTPS',
|
|
1966
|
+
pathname='/',
|
|
1967
|
+
method='POST',
|
|
1968
|
+
auth_type='Anonymous',
|
|
1969
|
+
style='RPC',
|
|
1970
|
+
req_body_type='formData',
|
|
1971
|
+
body_type='json'
|
|
1972
|
+
)
|
|
1973
|
+
return TeaCore.from_map(
|
|
1974
|
+
ecd_20201002_models.RefreshLoginTokenResponse(),
|
|
1975
|
+
self.call_api(params, req, runtime)
|
|
1976
|
+
)
|
|
1977
|
+
|
|
1978
|
+
async def refresh_login_token_with_options_async(
|
|
1979
|
+
self,
|
|
1980
|
+
request: ecd_20201002_models.RefreshLoginTokenRequest,
|
|
1981
|
+
runtime: util_models.RuntimeOptions,
|
|
1982
|
+
) -> ecd_20201002_models.RefreshLoginTokenResponse:
|
|
1983
|
+
"""
|
|
1984
|
+
@param request: RefreshLoginTokenRequest
|
|
1985
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
1986
|
+
@return: RefreshLoginTokenResponse
|
|
1987
|
+
"""
|
|
1988
|
+
UtilClient.validate_model(request)
|
|
1989
|
+
query = {}
|
|
1990
|
+
if not UtilClient.is_unset(request.client_id):
|
|
1991
|
+
query['ClientId'] = request.client_id
|
|
1992
|
+
if not UtilClient.is_unset(request.directory_id):
|
|
1993
|
+
query['DirectoryId'] = request.directory_id
|
|
1994
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
1995
|
+
query['EndUserId'] = request.end_user_id
|
|
1996
|
+
if not UtilClient.is_unset(request.login_token):
|
|
1997
|
+
query['LoginToken'] = request.login_token
|
|
1998
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
1999
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
2000
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2001
|
+
query['RegionId'] = request.region_id
|
|
2002
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2003
|
+
query['SessionId'] = request.session_id
|
|
2004
|
+
req = open_api_models.OpenApiRequest(
|
|
2005
|
+
query=OpenApiUtilClient.query(query)
|
|
2006
|
+
)
|
|
2007
|
+
params = open_api_models.Params(
|
|
2008
|
+
action='RefreshLoginToken',
|
|
2009
|
+
version='2020-10-02',
|
|
2010
|
+
protocol='HTTPS',
|
|
2011
|
+
pathname='/',
|
|
2012
|
+
method='POST',
|
|
2013
|
+
auth_type='Anonymous',
|
|
2014
|
+
style='RPC',
|
|
2015
|
+
req_body_type='formData',
|
|
2016
|
+
body_type='json'
|
|
2017
|
+
)
|
|
2018
|
+
return TeaCore.from_map(
|
|
2019
|
+
ecd_20201002_models.RefreshLoginTokenResponse(),
|
|
2020
|
+
await self.call_api_async(params, req, runtime)
|
|
2021
|
+
)
|
|
2022
|
+
|
|
2023
|
+
def refresh_login_token(
|
|
2024
|
+
self,
|
|
2025
|
+
request: ecd_20201002_models.RefreshLoginTokenRequest,
|
|
2026
|
+
) -> ecd_20201002_models.RefreshLoginTokenResponse:
|
|
2027
|
+
"""
|
|
2028
|
+
@param request: RefreshLoginTokenRequest
|
|
2029
|
+
@return: RefreshLoginTokenResponse
|
|
2030
|
+
"""
|
|
2031
|
+
runtime = util_models.RuntimeOptions()
|
|
2032
|
+
return self.refresh_login_token_with_options(request, runtime)
|
|
2033
|
+
|
|
2034
|
+
async def refresh_login_token_async(
|
|
2035
|
+
self,
|
|
2036
|
+
request: ecd_20201002_models.RefreshLoginTokenRequest,
|
|
2037
|
+
) -> ecd_20201002_models.RefreshLoginTokenResponse:
|
|
2038
|
+
"""
|
|
2039
|
+
@param request: RefreshLoginTokenRequest
|
|
2040
|
+
@return: RefreshLoginTokenResponse
|
|
2041
|
+
"""
|
|
2042
|
+
runtime = util_models.RuntimeOptions()
|
|
2043
|
+
return await self.refresh_login_token_with_options_async(request, runtime)
|
|
2044
|
+
|
|
2045
|
+
def report_eds_agent_info_with_options(
|
|
2046
|
+
self,
|
|
2047
|
+
request: ecd_20201002_models.ReportEdsAgentInfoRequest,
|
|
2048
|
+
runtime: util_models.RuntimeOptions,
|
|
2049
|
+
) -> ecd_20201002_models.ReportEdsAgentInfoResponse:
|
|
2050
|
+
"""
|
|
2051
|
+
@summary 上报edsAgent的信息
|
|
2052
|
+
|
|
2053
|
+
@param request: ReportEdsAgentInfoRequest
|
|
2054
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2055
|
+
@return: ReportEdsAgentInfoResponse
|
|
2056
|
+
"""
|
|
2057
|
+
UtilClient.validate_model(request)
|
|
2058
|
+
query = {}
|
|
2059
|
+
if not UtilClient.is_unset(request.ali_uid):
|
|
2060
|
+
query['AliUid'] = request.ali_uid
|
|
2061
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2062
|
+
query['DesktopId'] = request.desktop_id
|
|
2063
|
+
if not UtilClient.is_unset(request.ecs_instance_id):
|
|
2064
|
+
query['EcsInstanceId'] = request.ecs_instance_id
|
|
2065
|
+
if not UtilClient.is_unset(request.eds_agent_info):
|
|
2066
|
+
query['EdsAgentInfo'] = request.eds_agent_info
|
|
2067
|
+
req = open_api_models.OpenApiRequest(
|
|
2068
|
+
query=OpenApiUtilClient.query(query)
|
|
2069
|
+
)
|
|
2070
|
+
params = open_api_models.Params(
|
|
2071
|
+
action='ReportEdsAgentInfo',
|
|
2072
|
+
version='2020-10-02',
|
|
2073
|
+
protocol='HTTPS',
|
|
2074
|
+
pathname='/',
|
|
2075
|
+
method='POST',
|
|
2076
|
+
auth_type='Anonymous',
|
|
2077
|
+
style='RPC',
|
|
2078
|
+
req_body_type='formData',
|
|
2079
|
+
body_type='json'
|
|
2080
|
+
)
|
|
2081
|
+
return TeaCore.from_map(
|
|
2082
|
+
ecd_20201002_models.ReportEdsAgentInfoResponse(),
|
|
2083
|
+
self.call_api(params, req, runtime)
|
|
2084
|
+
)
|
|
2085
|
+
|
|
2086
|
+
async def report_eds_agent_info_with_options_async(
|
|
2087
|
+
self,
|
|
2088
|
+
request: ecd_20201002_models.ReportEdsAgentInfoRequest,
|
|
2089
|
+
runtime: util_models.RuntimeOptions,
|
|
2090
|
+
) -> ecd_20201002_models.ReportEdsAgentInfoResponse:
|
|
2091
|
+
"""
|
|
2092
|
+
@summary 上报edsAgent的信息
|
|
2093
|
+
|
|
2094
|
+
@param request: ReportEdsAgentInfoRequest
|
|
2095
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2096
|
+
@return: ReportEdsAgentInfoResponse
|
|
2097
|
+
"""
|
|
2098
|
+
UtilClient.validate_model(request)
|
|
2099
|
+
query = {}
|
|
2100
|
+
if not UtilClient.is_unset(request.ali_uid):
|
|
2101
|
+
query['AliUid'] = request.ali_uid
|
|
2102
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2103
|
+
query['DesktopId'] = request.desktop_id
|
|
2104
|
+
if not UtilClient.is_unset(request.ecs_instance_id):
|
|
2105
|
+
query['EcsInstanceId'] = request.ecs_instance_id
|
|
2106
|
+
if not UtilClient.is_unset(request.eds_agent_info):
|
|
2107
|
+
query['EdsAgentInfo'] = request.eds_agent_info
|
|
2108
|
+
req = open_api_models.OpenApiRequest(
|
|
2109
|
+
query=OpenApiUtilClient.query(query)
|
|
2110
|
+
)
|
|
2111
|
+
params = open_api_models.Params(
|
|
2112
|
+
action='ReportEdsAgentInfo',
|
|
2113
|
+
version='2020-10-02',
|
|
2114
|
+
protocol='HTTPS',
|
|
2115
|
+
pathname='/',
|
|
2116
|
+
method='POST',
|
|
2117
|
+
auth_type='Anonymous',
|
|
2118
|
+
style='RPC',
|
|
2119
|
+
req_body_type='formData',
|
|
2120
|
+
body_type='json'
|
|
2121
|
+
)
|
|
2122
|
+
return TeaCore.from_map(
|
|
2123
|
+
ecd_20201002_models.ReportEdsAgentInfoResponse(),
|
|
2124
|
+
await self.call_api_async(params, req, runtime)
|
|
2125
|
+
)
|
|
2126
|
+
|
|
2127
|
+
def report_eds_agent_info(
|
|
2128
|
+
self,
|
|
2129
|
+
request: ecd_20201002_models.ReportEdsAgentInfoRequest,
|
|
2130
|
+
) -> ecd_20201002_models.ReportEdsAgentInfoResponse:
|
|
2131
|
+
"""
|
|
2132
|
+
@summary 上报edsAgent的信息
|
|
2133
|
+
|
|
2134
|
+
@param request: ReportEdsAgentInfoRequest
|
|
2135
|
+
@return: ReportEdsAgentInfoResponse
|
|
2136
|
+
"""
|
|
2137
|
+
runtime = util_models.RuntimeOptions()
|
|
2138
|
+
return self.report_eds_agent_info_with_options(request, runtime)
|
|
2139
|
+
|
|
2140
|
+
async def report_eds_agent_info_async(
|
|
2141
|
+
self,
|
|
2142
|
+
request: ecd_20201002_models.ReportEdsAgentInfoRequest,
|
|
2143
|
+
) -> ecd_20201002_models.ReportEdsAgentInfoResponse:
|
|
2144
|
+
"""
|
|
2145
|
+
@summary 上报edsAgent的信息
|
|
2146
|
+
|
|
2147
|
+
@param request: ReportEdsAgentInfoRequest
|
|
2148
|
+
@return: ReportEdsAgentInfoResponse
|
|
2149
|
+
"""
|
|
2150
|
+
runtime = util_models.RuntimeOptions()
|
|
2151
|
+
return await self.report_eds_agent_info_with_options_async(request, runtime)
|
|
2152
|
+
|
|
2153
|
+
def report_session_status_with_options(
|
|
2154
|
+
self,
|
|
2155
|
+
request: ecd_20201002_models.ReportSessionStatusRequest,
|
|
2156
|
+
runtime: util_models.RuntimeOptions,
|
|
2157
|
+
) -> ecd_20201002_models.ReportSessionStatusResponse:
|
|
2158
|
+
"""
|
|
2159
|
+
@param request: ReportSessionStatusRequest
|
|
2160
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2161
|
+
@return: ReportSessionStatusResponse
|
|
2162
|
+
"""
|
|
2163
|
+
UtilClient.validate_model(request)
|
|
2164
|
+
query = {}
|
|
2165
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
2166
|
+
query['EndUserId'] = request.end_user_id
|
|
2167
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
2168
|
+
query['InstanceId'] = request.instance_id
|
|
2169
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2170
|
+
query['RegionId'] = request.region_id
|
|
2171
|
+
if not UtilClient.is_unset(request.session_change_time):
|
|
2172
|
+
query['SessionChangeTime'] = request.session_change_time
|
|
2173
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2174
|
+
query['SessionId'] = request.session_id
|
|
2175
|
+
if not UtilClient.is_unset(request.session_status):
|
|
2176
|
+
query['SessionStatus'] = request.session_status
|
|
2177
|
+
req = open_api_models.OpenApiRequest(
|
|
2178
|
+
query=OpenApiUtilClient.query(query)
|
|
2179
|
+
)
|
|
2180
|
+
params = open_api_models.Params(
|
|
2181
|
+
action='ReportSessionStatus',
|
|
2182
|
+
version='2020-10-02',
|
|
2183
|
+
protocol='HTTPS',
|
|
2184
|
+
pathname='/',
|
|
2185
|
+
method='POST',
|
|
2186
|
+
auth_type='Anonymous',
|
|
2187
|
+
style='RPC',
|
|
2188
|
+
req_body_type='formData',
|
|
2189
|
+
body_type='json'
|
|
2190
|
+
)
|
|
2191
|
+
return TeaCore.from_map(
|
|
2192
|
+
ecd_20201002_models.ReportSessionStatusResponse(),
|
|
2193
|
+
self.call_api(params, req, runtime)
|
|
2194
|
+
)
|
|
2195
|
+
|
|
2196
|
+
async def report_session_status_with_options_async(
|
|
2197
|
+
self,
|
|
2198
|
+
request: ecd_20201002_models.ReportSessionStatusRequest,
|
|
2199
|
+
runtime: util_models.RuntimeOptions,
|
|
2200
|
+
) -> ecd_20201002_models.ReportSessionStatusResponse:
|
|
2201
|
+
"""
|
|
2202
|
+
@param request: ReportSessionStatusRequest
|
|
2203
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2204
|
+
@return: ReportSessionStatusResponse
|
|
2205
|
+
"""
|
|
2206
|
+
UtilClient.validate_model(request)
|
|
2207
|
+
query = {}
|
|
2208
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
2209
|
+
query['EndUserId'] = request.end_user_id
|
|
2210
|
+
if not UtilClient.is_unset(request.instance_id):
|
|
2211
|
+
query['InstanceId'] = request.instance_id
|
|
2212
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2213
|
+
query['RegionId'] = request.region_id
|
|
2214
|
+
if not UtilClient.is_unset(request.session_change_time):
|
|
2215
|
+
query['SessionChangeTime'] = request.session_change_time
|
|
2216
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2217
|
+
query['SessionId'] = request.session_id
|
|
2218
|
+
if not UtilClient.is_unset(request.session_status):
|
|
2219
|
+
query['SessionStatus'] = request.session_status
|
|
2220
|
+
req = open_api_models.OpenApiRequest(
|
|
2221
|
+
query=OpenApiUtilClient.query(query)
|
|
2222
|
+
)
|
|
2223
|
+
params = open_api_models.Params(
|
|
2224
|
+
action='ReportSessionStatus',
|
|
2225
|
+
version='2020-10-02',
|
|
2226
|
+
protocol='HTTPS',
|
|
2227
|
+
pathname='/',
|
|
2228
|
+
method='POST',
|
|
2229
|
+
auth_type='Anonymous',
|
|
2230
|
+
style='RPC',
|
|
2231
|
+
req_body_type='formData',
|
|
2232
|
+
body_type='json'
|
|
2233
|
+
)
|
|
2234
|
+
return TeaCore.from_map(
|
|
2235
|
+
ecd_20201002_models.ReportSessionStatusResponse(),
|
|
2236
|
+
await self.call_api_async(params, req, runtime)
|
|
2237
|
+
)
|
|
2238
|
+
|
|
2239
|
+
def report_session_status(
|
|
2240
|
+
self,
|
|
2241
|
+
request: ecd_20201002_models.ReportSessionStatusRequest,
|
|
2242
|
+
) -> ecd_20201002_models.ReportSessionStatusResponse:
|
|
2243
|
+
"""
|
|
2244
|
+
@param request: ReportSessionStatusRequest
|
|
2245
|
+
@return: ReportSessionStatusResponse
|
|
2246
|
+
"""
|
|
2247
|
+
runtime = util_models.RuntimeOptions()
|
|
2248
|
+
return self.report_session_status_with_options(request, runtime)
|
|
2249
|
+
|
|
2250
|
+
async def report_session_status_async(
|
|
2251
|
+
self,
|
|
2252
|
+
request: ecd_20201002_models.ReportSessionStatusRequest,
|
|
2253
|
+
) -> ecd_20201002_models.ReportSessionStatusResponse:
|
|
2254
|
+
"""
|
|
2255
|
+
@param request: ReportSessionStatusRequest
|
|
2256
|
+
@return: ReportSessionStatusResponse
|
|
2257
|
+
"""
|
|
2258
|
+
runtime = util_models.RuntimeOptions()
|
|
2259
|
+
return await self.report_session_status_with_options_async(request, runtime)
|
|
2260
|
+
|
|
2261
|
+
def reset_password_with_options(
|
|
2262
|
+
self,
|
|
2263
|
+
request: ecd_20201002_models.ResetPasswordRequest,
|
|
2264
|
+
runtime: util_models.RuntimeOptions,
|
|
2265
|
+
) -> ecd_20201002_models.ResetPasswordResponse:
|
|
2266
|
+
"""
|
|
2267
|
+
@param request: ResetPasswordRequest
|
|
2268
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2269
|
+
@return: ResetPasswordResponse
|
|
2270
|
+
"""
|
|
2271
|
+
UtilClient.validate_model(request)
|
|
2272
|
+
query = {}
|
|
2273
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2274
|
+
query['ClientId'] = request.client_id
|
|
2275
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2276
|
+
query['ClientToken'] = request.client_token
|
|
2277
|
+
if not UtilClient.is_unset(request.email):
|
|
2278
|
+
query['Email'] = request.email
|
|
2279
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
2280
|
+
query['EndUserId'] = request.end_user_id
|
|
2281
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
2282
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
2283
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2284
|
+
query['RegionId'] = request.region_id
|
|
2285
|
+
if not UtilClient.is_unset(request.phone):
|
|
2286
|
+
query['phone'] = request.phone
|
|
2287
|
+
req = open_api_models.OpenApiRequest(
|
|
2288
|
+
query=OpenApiUtilClient.query(query)
|
|
2289
|
+
)
|
|
2290
|
+
params = open_api_models.Params(
|
|
2291
|
+
action='ResetPassword',
|
|
2292
|
+
version='2020-10-02',
|
|
2293
|
+
protocol='HTTPS',
|
|
2294
|
+
pathname='/',
|
|
2295
|
+
method='POST',
|
|
2296
|
+
auth_type='Anonymous',
|
|
2297
|
+
style='RPC',
|
|
2298
|
+
req_body_type='formData',
|
|
2299
|
+
body_type='json'
|
|
2300
|
+
)
|
|
2301
|
+
return TeaCore.from_map(
|
|
2302
|
+
ecd_20201002_models.ResetPasswordResponse(),
|
|
2303
|
+
self.call_api(params, req, runtime)
|
|
2304
|
+
)
|
|
2305
|
+
|
|
2306
|
+
async def reset_password_with_options_async(
|
|
2307
|
+
self,
|
|
2308
|
+
request: ecd_20201002_models.ResetPasswordRequest,
|
|
2309
|
+
runtime: util_models.RuntimeOptions,
|
|
2310
|
+
) -> ecd_20201002_models.ResetPasswordResponse:
|
|
2311
|
+
"""
|
|
2312
|
+
@param request: ResetPasswordRequest
|
|
2313
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2314
|
+
@return: ResetPasswordResponse
|
|
2315
|
+
"""
|
|
2316
|
+
UtilClient.validate_model(request)
|
|
2317
|
+
query = {}
|
|
2318
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2319
|
+
query['ClientId'] = request.client_id
|
|
2320
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2321
|
+
query['ClientToken'] = request.client_token
|
|
2322
|
+
if not UtilClient.is_unset(request.email):
|
|
2323
|
+
query['Email'] = request.email
|
|
2324
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
2325
|
+
query['EndUserId'] = request.end_user_id
|
|
2326
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
2327
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
2328
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2329
|
+
query['RegionId'] = request.region_id
|
|
2330
|
+
if not UtilClient.is_unset(request.phone):
|
|
2331
|
+
query['phone'] = request.phone
|
|
2332
|
+
req = open_api_models.OpenApiRequest(
|
|
2333
|
+
query=OpenApiUtilClient.query(query)
|
|
2334
|
+
)
|
|
2335
|
+
params = open_api_models.Params(
|
|
2336
|
+
action='ResetPassword',
|
|
2337
|
+
version='2020-10-02',
|
|
2338
|
+
protocol='HTTPS',
|
|
2339
|
+
pathname='/',
|
|
2340
|
+
method='POST',
|
|
2341
|
+
auth_type='Anonymous',
|
|
2342
|
+
style='RPC',
|
|
2343
|
+
req_body_type='formData',
|
|
2344
|
+
body_type='json'
|
|
2345
|
+
)
|
|
2346
|
+
return TeaCore.from_map(
|
|
2347
|
+
ecd_20201002_models.ResetPasswordResponse(),
|
|
2348
|
+
await self.call_api_async(params, req, runtime)
|
|
2349
|
+
)
|
|
2350
|
+
|
|
2351
|
+
def reset_password(
|
|
2352
|
+
self,
|
|
2353
|
+
request: ecd_20201002_models.ResetPasswordRequest,
|
|
2354
|
+
) -> ecd_20201002_models.ResetPasswordResponse:
|
|
2355
|
+
"""
|
|
2356
|
+
@param request: ResetPasswordRequest
|
|
2357
|
+
@return: ResetPasswordResponse
|
|
2358
|
+
"""
|
|
2359
|
+
runtime = util_models.RuntimeOptions()
|
|
2360
|
+
return self.reset_password_with_options(request, runtime)
|
|
2361
|
+
|
|
2362
|
+
async def reset_password_async(
|
|
2363
|
+
self,
|
|
2364
|
+
request: ecd_20201002_models.ResetPasswordRequest,
|
|
2365
|
+
) -> ecd_20201002_models.ResetPasswordResponse:
|
|
2366
|
+
"""
|
|
2367
|
+
@param request: ResetPasswordRequest
|
|
2368
|
+
@return: ResetPasswordResponse
|
|
2369
|
+
"""
|
|
2370
|
+
runtime = util_models.RuntimeOptions()
|
|
2371
|
+
return await self.reset_password_with_options_async(request, runtime)
|
|
2372
|
+
|
|
2373
|
+
def reset_snapshot_with_options(
|
|
2374
|
+
self,
|
|
2375
|
+
request: ecd_20201002_models.ResetSnapshotRequest,
|
|
2376
|
+
runtime: util_models.RuntimeOptions,
|
|
2377
|
+
) -> ecd_20201002_models.ResetSnapshotResponse:
|
|
2378
|
+
"""
|
|
2379
|
+
@summary 还原快照
|
|
2380
|
+
|
|
2381
|
+
@param request: ResetSnapshotRequest
|
|
2382
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2383
|
+
@return: ResetSnapshotResponse
|
|
2384
|
+
"""
|
|
2385
|
+
UtilClient.validate_model(request)
|
|
2386
|
+
query = {}
|
|
2387
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2388
|
+
query['ClientId'] = request.client_id
|
|
2389
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2390
|
+
query['DesktopId'] = request.desktop_id
|
|
2391
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2392
|
+
query['LoginToken'] = request.login_token
|
|
2393
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2394
|
+
query['RegionId'] = request.region_id
|
|
2395
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2396
|
+
query['SessionId'] = request.session_id
|
|
2397
|
+
if not UtilClient.is_unset(request.snapshot_id):
|
|
2398
|
+
query['SnapshotId'] = request.snapshot_id
|
|
2399
|
+
if not UtilClient.is_unset(request.stop_desktop):
|
|
2400
|
+
query['StopDesktop'] = request.stop_desktop
|
|
2401
|
+
req = open_api_models.OpenApiRequest(
|
|
2402
|
+
query=OpenApiUtilClient.query(query)
|
|
2403
|
+
)
|
|
2404
|
+
params = open_api_models.Params(
|
|
2405
|
+
action='ResetSnapshot',
|
|
2406
|
+
version='2020-10-02',
|
|
2407
|
+
protocol='HTTPS',
|
|
2408
|
+
pathname='/',
|
|
2409
|
+
method='POST',
|
|
2410
|
+
auth_type='Anonymous',
|
|
2411
|
+
style='RPC',
|
|
2412
|
+
req_body_type='formData',
|
|
2413
|
+
body_type='json'
|
|
2414
|
+
)
|
|
2415
|
+
return TeaCore.from_map(
|
|
2416
|
+
ecd_20201002_models.ResetSnapshotResponse(),
|
|
2417
|
+
self.call_api(params, req, runtime)
|
|
2418
|
+
)
|
|
2419
|
+
|
|
2420
|
+
async def reset_snapshot_with_options_async(
|
|
2421
|
+
self,
|
|
2422
|
+
request: ecd_20201002_models.ResetSnapshotRequest,
|
|
2423
|
+
runtime: util_models.RuntimeOptions,
|
|
2424
|
+
) -> ecd_20201002_models.ResetSnapshotResponse:
|
|
2425
|
+
"""
|
|
2426
|
+
@summary 还原快照
|
|
2427
|
+
|
|
2428
|
+
@param request: ResetSnapshotRequest
|
|
2429
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2430
|
+
@return: ResetSnapshotResponse
|
|
2431
|
+
"""
|
|
2432
|
+
UtilClient.validate_model(request)
|
|
2433
|
+
query = {}
|
|
2434
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2435
|
+
query['ClientId'] = request.client_id
|
|
2436
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2437
|
+
query['DesktopId'] = request.desktop_id
|
|
2438
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2439
|
+
query['LoginToken'] = request.login_token
|
|
2440
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2441
|
+
query['RegionId'] = request.region_id
|
|
2442
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2443
|
+
query['SessionId'] = request.session_id
|
|
2444
|
+
if not UtilClient.is_unset(request.snapshot_id):
|
|
2445
|
+
query['SnapshotId'] = request.snapshot_id
|
|
2446
|
+
if not UtilClient.is_unset(request.stop_desktop):
|
|
2447
|
+
query['StopDesktop'] = request.stop_desktop
|
|
2448
|
+
req = open_api_models.OpenApiRequest(
|
|
2449
|
+
query=OpenApiUtilClient.query(query)
|
|
2450
|
+
)
|
|
2451
|
+
params = open_api_models.Params(
|
|
2452
|
+
action='ResetSnapshot',
|
|
2453
|
+
version='2020-10-02',
|
|
2454
|
+
protocol='HTTPS',
|
|
2455
|
+
pathname='/',
|
|
2456
|
+
method='POST',
|
|
2457
|
+
auth_type='Anonymous',
|
|
2458
|
+
style='RPC',
|
|
2459
|
+
req_body_type='formData',
|
|
2460
|
+
body_type='json'
|
|
2461
|
+
)
|
|
2462
|
+
return TeaCore.from_map(
|
|
2463
|
+
ecd_20201002_models.ResetSnapshotResponse(),
|
|
2464
|
+
await self.call_api_async(params, req, runtime)
|
|
2465
|
+
)
|
|
2466
|
+
|
|
2467
|
+
def reset_snapshot(
|
|
2468
|
+
self,
|
|
2469
|
+
request: ecd_20201002_models.ResetSnapshotRequest,
|
|
2470
|
+
) -> ecd_20201002_models.ResetSnapshotResponse:
|
|
2471
|
+
"""
|
|
2472
|
+
@summary 还原快照
|
|
2473
|
+
|
|
2474
|
+
@param request: ResetSnapshotRequest
|
|
2475
|
+
@return: ResetSnapshotResponse
|
|
2476
|
+
"""
|
|
2477
|
+
runtime = util_models.RuntimeOptions()
|
|
2478
|
+
return self.reset_snapshot_with_options(request, runtime)
|
|
2479
|
+
|
|
2480
|
+
async def reset_snapshot_async(
|
|
2481
|
+
self,
|
|
2482
|
+
request: ecd_20201002_models.ResetSnapshotRequest,
|
|
2483
|
+
) -> ecd_20201002_models.ResetSnapshotResponse:
|
|
2484
|
+
"""
|
|
2485
|
+
@summary 还原快照
|
|
2486
|
+
|
|
2487
|
+
@param request: ResetSnapshotRequest
|
|
2488
|
+
@return: ResetSnapshotResponse
|
|
2489
|
+
"""
|
|
2490
|
+
runtime = util_models.RuntimeOptions()
|
|
2491
|
+
return await self.reset_snapshot_with_options_async(request, runtime)
|
|
2492
|
+
|
|
2493
|
+
def send_token_code_with_options(
|
|
2494
|
+
self,
|
|
2495
|
+
request: ecd_20201002_models.SendTokenCodeRequest,
|
|
2496
|
+
runtime: util_models.RuntimeOptions,
|
|
2497
|
+
) -> ecd_20201002_models.SendTokenCodeResponse:
|
|
2498
|
+
"""
|
|
2499
|
+
@param request: SendTokenCodeRequest
|
|
2500
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2501
|
+
@return: SendTokenCodeResponse
|
|
2502
|
+
"""
|
|
2503
|
+
UtilClient.validate_model(request)
|
|
2504
|
+
query = {}
|
|
2505
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2506
|
+
query['ClientId'] = request.client_id
|
|
2507
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2508
|
+
query['ClientOS'] = request.client_os
|
|
2509
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2510
|
+
query['ClientVersion'] = request.client_version
|
|
2511
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
2512
|
+
query['EndUserId'] = request.end_user_id
|
|
2513
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2514
|
+
query['LoginToken'] = request.login_token
|
|
2515
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
2516
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
2517
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2518
|
+
query['SessionId'] = request.session_id
|
|
2519
|
+
if not UtilClient.is_unset(request.token_code):
|
|
2520
|
+
query['TokenCode'] = request.token_code
|
|
2521
|
+
req = open_api_models.OpenApiRequest(
|
|
2522
|
+
query=OpenApiUtilClient.query(query)
|
|
2523
|
+
)
|
|
2524
|
+
params = open_api_models.Params(
|
|
2525
|
+
action='SendTokenCode',
|
|
2526
|
+
version='2020-10-02',
|
|
2527
|
+
protocol='HTTPS',
|
|
2528
|
+
pathname='/',
|
|
2529
|
+
method='POST',
|
|
2530
|
+
auth_type='Anonymous',
|
|
2531
|
+
style='RPC',
|
|
2532
|
+
req_body_type='formData',
|
|
2533
|
+
body_type='json'
|
|
2534
|
+
)
|
|
2535
|
+
return TeaCore.from_map(
|
|
2536
|
+
ecd_20201002_models.SendTokenCodeResponse(),
|
|
2537
|
+
self.call_api(params, req, runtime)
|
|
2538
|
+
)
|
|
2539
|
+
|
|
2540
|
+
async def send_token_code_with_options_async(
|
|
2541
|
+
self,
|
|
2542
|
+
request: ecd_20201002_models.SendTokenCodeRequest,
|
|
2543
|
+
runtime: util_models.RuntimeOptions,
|
|
2544
|
+
) -> ecd_20201002_models.SendTokenCodeResponse:
|
|
2545
|
+
"""
|
|
2546
|
+
@param request: SendTokenCodeRequest
|
|
2547
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2548
|
+
@return: SendTokenCodeResponse
|
|
2549
|
+
"""
|
|
2550
|
+
UtilClient.validate_model(request)
|
|
2551
|
+
query = {}
|
|
2552
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2553
|
+
query['ClientId'] = request.client_id
|
|
2554
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2555
|
+
query['ClientOS'] = request.client_os
|
|
2556
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2557
|
+
query['ClientVersion'] = request.client_version
|
|
2558
|
+
if not UtilClient.is_unset(request.end_user_id):
|
|
2559
|
+
query['EndUserId'] = request.end_user_id
|
|
2560
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2561
|
+
query['LoginToken'] = request.login_token
|
|
2562
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
2563
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
2564
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2565
|
+
query['SessionId'] = request.session_id
|
|
2566
|
+
if not UtilClient.is_unset(request.token_code):
|
|
2567
|
+
query['TokenCode'] = request.token_code
|
|
2568
|
+
req = open_api_models.OpenApiRequest(
|
|
2569
|
+
query=OpenApiUtilClient.query(query)
|
|
2570
|
+
)
|
|
2571
|
+
params = open_api_models.Params(
|
|
2572
|
+
action='SendTokenCode',
|
|
2573
|
+
version='2020-10-02',
|
|
2574
|
+
protocol='HTTPS',
|
|
2575
|
+
pathname='/',
|
|
2576
|
+
method='POST',
|
|
2577
|
+
auth_type='Anonymous',
|
|
2578
|
+
style='RPC',
|
|
2579
|
+
req_body_type='formData',
|
|
2580
|
+
body_type='json'
|
|
2581
|
+
)
|
|
2582
|
+
return TeaCore.from_map(
|
|
2583
|
+
ecd_20201002_models.SendTokenCodeResponse(),
|
|
2584
|
+
await self.call_api_async(params, req, runtime)
|
|
2585
|
+
)
|
|
2586
|
+
|
|
2587
|
+
def send_token_code(
|
|
2588
|
+
self,
|
|
2589
|
+
request: ecd_20201002_models.SendTokenCodeRequest,
|
|
2590
|
+
) -> ecd_20201002_models.SendTokenCodeResponse:
|
|
2591
|
+
"""
|
|
2592
|
+
@param request: SendTokenCodeRequest
|
|
2593
|
+
@return: SendTokenCodeResponse
|
|
2594
|
+
"""
|
|
2595
|
+
runtime = util_models.RuntimeOptions()
|
|
2596
|
+
return self.send_token_code_with_options(request, runtime)
|
|
2597
|
+
|
|
2598
|
+
async def send_token_code_async(
|
|
2599
|
+
self,
|
|
2600
|
+
request: ecd_20201002_models.SendTokenCodeRequest,
|
|
2601
|
+
) -> ecd_20201002_models.SendTokenCodeResponse:
|
|
2602
|
+
"""
|
|
2603
|
+
@param request: SendTokenCodeRequest
|
|
2604
|
+
@return: SendTokenCodeResponse
|
|
2605
|
+
"""
|
|
2606
|
+
runtime = util_models.RuntimeOptions()
|
|
2607
|
+
return await self.send_token_code_with_options_async(request, runtime)
|
|
2608
|
+
|
|
2609
|
+
def set_finger_print_template_with_options(
|
|
2610
|
+
self,
|
|
2611
|
+
request: ecd_20201002_models.SetFingerPrintTemplateRequest,
|
|
2612
|
+
runtime: util_models.RuntimeOptions,
|
|
2613
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateResponse:
|
|
2614
|
+
"""
|
|
2615
|
+
@param request: SetFingerPrintTemplateRequest
|
|
2616
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2617
|
+
@return: SetFingerPrintTemplateResponse
|
|
2618
|
+
"""
|
|
2619
|
+
UtilClient.validate_model(request)
|
|
2620
|
+
query = {}
|
|
2621
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2622
|
+
query['ClientId'] = request.client_id
|
|
2623
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2624
|
+
query['ClientToken'] = request.client_token
|
|
2625
|
+
if not UtilClient.is_unset(request.description):
|
|
2626
|
+
query['Description'] = request.description
|
|
2627
|
+
if not UtilClient.is_unset(request.encrypted_finger_print_template):
|
|
2628
|
+
query['EncryptedFingerPrintTemplate'] = request.encrypted_finger_print_template
|
|
2629
|
+
if not UtilClient.is_unset(request.encrypted_key):
|
|
2630
|
+
query['EncryptedKey'] = request.encrypted_key
|
|
2631
|
+
if not UtilClient.is_unset(request.finger_print_template):
|
|
2632
|
+
query['FingerPrintTemplate'] = request.finger_print_template
|
|
2633
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2634
|
+
query['LoginToken'] = request.login_token
|
|
2635
|
+
if not UtilClient.is_unset(request.password):
|
|
2636
|
+
query['Password'] = request.password
|
|
2637
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2638
|
+
query['RegionId'] = request.region_id
|
|
2639
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2640
|
+
query['SessionId'] = request.session_id
|
|
2641
|
+
req = open_api_models.OpenApiRequest(
|
|
2642
|
+
query=OpenApiUtilClient.query(query)
|
|
2643
|
+
)
|
|
2644
|
+
params = open_api_models.Params(
|
|
2645
|
+
action='SetFingerPrintTemplate',
|
|
2646
|
+
version='2020-10-02',
|
|
2647
|
+
protocol='HTTPS',
|
|
2648
|
+
pathname='/',
|
|
2649
|
+
method='POST',
|
|
2650
|
+
auth_type='Anonymous',
|
|
2651
|
+
style='RPC',
|
|
2652
|
+
req_body_type='formData',
|
|
2653
|
+
body_type='json'
|
|
2654
|
+
)
|
|
2655
|
+
return TeaCore.from_map(
|
|
2656
|
+
ecd_20201002_models.SetFingerPrintTemplateResponse(),
|
|
2657
|
+
self.call_api(params, req, runtime)
|
|
2658
|
+
)
|
|
2659
|
+
|
|
2660
|
+
async def set_finger_print_template_with_options_async(
|
|
2661
|
+
self,
|
|
2662
|
+
request: ecd_20201002_models.SetFingerPrintTemplateRequest,
|
|
2663
|
+
runtime: util_models.RuntimeOptions,
|
|
2664
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateResponse:
|
|
2665
|
+
"""
|
|
2666
|
+
@param request: SetFingerPrintTemplateRequest
|
|
2667
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2668
|
+
@return: SetFingerPrintTemplateResponse
|
|
2669
|
+
"""
|
|
2670
|
+
UtilClient.validate_model(request)
|
|
2671
|
+
query = {}
|
|
2672
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2673
|
+
query['ClientId'] = request.client_id
|
|
2674
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2675
|
+
query['ClientToken'] = request.client_token
|
|
2676
|
+
if not UtilClient.is_unset(request.description):
|
|
2677
|
+
query['Description'] = request.description
|
|
2678
|
+
if not UtilClient.is_unset(request.encrypted_finger_print_template):
|
|
2679
|
+
query['EncryptedFingerPrintTemplate'] = request.encrypted_finger_print_template
|
|
2680
|
+
if not UtilClient.is_unset(request.encrypted_key):
|
|
2681
|
+
query['EncryptedKey'] = request.encrypted_key
|
|
2682
|
+
if not UtilClient.is_unset(request.finger_print_template):
|
|
2683
|
+
query['FingerPrintTemplate'] = request.finger_print_template
|
|
2684
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2685
|
+
query['LoginToken'] = request.login_token
|
|
2686
|
+
if not UtilClient.is_unset(request.password):
|
|
2687
|
+
query['Password'] = request.password
|
|
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='SetFingerPrintTemplate',
|
|
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.SetFingerPrintTemplateResponse(),
|
|
2708
|
+
await self.call_api_async(params, req, runtime)
|
|
2709
|
+
)
|
|
2710
|
+
|
|
2711
|
+
def set_finger_print_template(
|
|
2712
|
+
self,
|
|
2713
|
+
request: ecd_20201002_models.SetFingerPrintTemplateRequest,
|
|
2714
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateResponse:
|
|
2715
|
+
"""
|
|
2716
|
+
@param request: SetFingerPrintTemplateRequest
|
|
2717
|
+
@return: SetFingerPrintTemplateResponse
|
|
2718
|
+
"""
|
|
2719
|
+
runtime = util_models.RuntimeOptions()
|
|
2720
|
+
return self.set_finger_print_template_with_options(request, runtime)
|
|
2721
|
+
|
|
2722
|
+
async def set_finger_print_template_async(
|
|
2723
|
+
self,
|
|
2724
|
+
request: ecd_20201002_models.SetFingerPrintTemplateRequest,
|
|
2725
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateResponse:
|
|
2726
|
+
"""
|
|
2727
|
+
@param request: SetFingerPrintTemplateRequest
|
|
2728
|
+
@return: SetFingerPrintTemplateResponse
|
|
2729
|
+
"""
|
|
2730
|
+
runtime = util_models.RuntimeOptions()
|
|
2731
|
+
return await self.set_finger_print_template_with_options_async(request, runtime)
|
|
2732
|
+
|
|
2733
|
+
def set_finger_print_template_description_with_options(
|
|
2734
|
+
self,
|
|
2735
|
+
request: ecd_20201002_models.SetFingerPrintTemplateDescriptionRequest,
|
|
2736
|
+
runtime: util_models.RuntimeOptions,
|
|
2737
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse:
|
|
2738
|
+
"""
|
|
2739
|
+
@param request: SetFingerPrintTemplateDescriptionRequest
|
|
2740
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2741
|
+
@return: SetFingerPrintTemplateDescriptionResponse
|
|
2742
|
+
"""
|
|
2743
|
+
UtilClient.validate_model(request)
|
|
2744
|
+
query = {}
|
|
2745
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2746
|
+
query['ClientId'] = request.client_id
|
|
2747
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2748
|
+
query['ClientToken'] = request.client_token
|
|
2749
|
+
if not UtilClient.is_unset(request.description):
|
|
2750
|
+
query['Description'] = request.description
|
|
2751
|
+
if not UtilClient.is_unset(request.index):
|
|
2752
|
+
query['Index'] = request.index
|
|
2753
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2754
|
+
query['LoginToken'] = request.login_token
|
|
2755
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2756
|
+
query['RegionId'] = request.region_id
|
|
2757
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2758
|
+
query['SessionId'] = request.session_id
|
|
2759
|
+
req = open_api_models.OpenApiRequest(
|
|
2760
|
+
query=OpenApiUtilClient.query(query)
|
|
2761
|
+
)
|
|
2762
|
+
params = open_api_models.Params(
|
|
2763
|
+
action='SetFingerPrintTemplateDescription',
|
|
2764
|
+
version='2020-10-02',
|
|
2765
|
+
protocol='HTTPS',
|
|
2766
|
+
pathname='/',
|
|
2767
|
+
method='POST',
|
|
2768
|
+
auth_type='Anonymous',
|
|
2769
|
+
style='RPC',
|
|
2770
|
+
req_body_type='formData',
|
|
2771
|
+
body_type='json'
|
|
2772
|
+
)
|
|
2773
|
+
return TeaCore.from_map(
|
|
2774
|
+
ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse(),
|
|
2775
|
+
self.call_api(params, req, runtime)
|
|
2776
|
+
)
|
|
2777
|
+
|
|
2778
|
+
async def set_finger_print_template_description_with_options_async(
|
|
2779
|
+
self,
|
|
2780
|
+
request: ecd_20201002_models.SetFingerPrintTemplateDescriptionRequest,
|
|
2781
|
+
runtime: util_models.RuntimeOptions,
|
|
2782
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse:
|
|
2783
|
+
"""
|
|
2784
|
+
@param request: SetFingerPrintTemplateDescriptionRequest
|
|
2785
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2786
|
+
@return: SetFingerPrintTemplateDescriptionResponse
|
|
2787
|
+
"""
|
|
2788
|
+
UtilClient.validate_model(request)
|
|
2789
|
+
query = {}
|
|
2790
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2791
|
+
query['ClientId'] = request.client_id
|
|
2792
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2793
|
+
query['ClientToken'] = request.client_token
|
|
2794
|
+
if not UtilClient.is_unset(request.description):
|
|
2795
|
+
query['Description'] = request.description
|
|
2796
|
+
if not UtilClient.is_unset(request.index):
|
|
2797
|
+
query['Index'] = request.index
|
|
2798
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2799
|
+
query['LoginToken'] = request.login_token
|
|
2800
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2801
|
+
query['RegionId'] = request.region_id
|
|
2802
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2803
|
+
query['SessionId'] = request.session_id
|
|
2804
|
+
req = open_api_models.OpenApiRequest(
|
|
2805
|
+
query=OpenApiUtilClient.query(query)
|
|
2806
|
+
)
|
|
2807
|
+
params = open_api_models.Params(
|
|
2808
|
+
action='SetFingerPrintTemplateDescription',
|
|
2809
|
+
version='2020-10-02',
|
|
2810
|
+
protocol='HTTPS',
|
|
2811
|
+
pathname='/',
|
|
2812
|
+
method='POST',
|
|
2813
|
+
auth_type='Anonymous',
|
|
2814
|
+
style='RPC',
|
|
2815
|
+
req_body_type='formData',
|
|
2816
|
+
body_type='json'
|
|
2817
|
+
)
|
|
2818
|
+
return TeaCore.from_map(
|
|
2819
|
+
ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse(),
|
|
2820
|
+
await self.call_api_async(params, req, runtime)
|
|
2821
|
+
)
|
|
2822
|
+
|
|
2823
|
+
def set_finger_print_template_description(
|
|
2824
|
+
self,
|
|
2825
|
+
request: ecd_20201002_models.SetFingerPrintTemplateDescriptionRequest,
|
|
2826
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse:
|
|
2827
|
+
"""
|
|
2828
|
+
@param request: SetFingerPrintTemplateDescriptionRequest
|
|
2829
|
+
@return: SetFingerPrintTemplateDescriptionResponse
|
|
2830
|
+
"""
|
|
2831
|
+
runtime = util_models.RuntimeOptions()
|
|
2832
|
+
return self.set_finger_print_template_description_with_options(request, runtime)
|
|
2833
|
+
|
|
2834
|
+
async def set_finger_print_template_description_async(
|
|
2835
|
+
self,
|
|
2836
|
+
request: ecd_20201002_models.SetFingerPrintTemplateDescriptionRequest,
|
|
2837
|
+
) -> ecd_20201002_models.SetFingerPrintTemplateDescriptionResponse:
|
|
2838
|
+
"""
|
|
2839
|
+
@param request: SetFingerPrintTemplateDescriptionRequest
|
|
2840
|
+
@return: SetFingerPrintTemplateDescriptionResponse
|
|
2841
|
+
"""
|
|
2842
|
+
runtime = util_models.RuntimeOptions()
|
|
2843
|
+
return await self.set_finger_print_template_description_with_options_async(request, runtime)
|
|
2844
|
+
|
|
2845
|
+
def start_desktops_with_options(
|
|
2846
|
+
self,
|
|
2847
|
+
request: ecd_20201002_models.StartDesktopsRequest,
|
|
2848
|
+
runtime: util_models.RuntimeOptions,
|
|
2849
|
+
) -> ecd_20201002_models.StartDesktopsResponse:
|
|
2850
|
+
"""
|
|
2851
|
+
@summary Start cloud computers.
|
|
2852
|
+
|
|
2853
|
+
@description The cloud computers that you want to start must be in the Stopped state. After you call this operation, the cloud computers enter the Running state.
|
|
2854
|
+
|
|
2855
|
+
@param request: StartDesktopsRequest
|
|
2856
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2857
|
+
@return: StartDesktopsResponse
|
|
2858
|
+
"""
|
|
2859
|
+
UtilClient.validate_model(request)
|
|
2860
|
+
query = {}
|
|
2861
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2862
|
+
query['ClientId'] = request.client_id
|
|
2863
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2864
|
+
query['ClientOS'] = request.client_os
|
|
2865
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2866
|
+
query['ClientToken'] = request.client_token
|
|
2867
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2868
|
+
query['ClientVersion'] = request.client_version
|
|
2869
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2870
|
+
query['DesktopId'] = request.desktop_id
|
|
2871
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2872
|
+
query['LoginToken'] = request.login_token
|
|
2873
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2874
|
+
query['RegionId'] = request.region_id
|
|
2875
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2876
|
+
query['SessionId'] = request.session_id
|
|
2877
|
+
if not UtilClient.is_unset(request.uuid):
|
|
2878
|
+
query['Uuid'] = request.uuid
|
|
2879
|
+
req = open_api_models.OpenApiRequest(
|
|
2880
|
+
query=OpenApiUtilClient.query(query)
|
|
2881
|
+
)
|
|
2882
|
+
params = open_api_models.Params(
|
|
2883
|
+
action='StartDesktops',
|
|
2884
|
+
version='2020-10-02',
|
|
2885
|
+
protocol='HTTPS',
|
|
2886
|
+
pathname='/',
|
|
2887
|
+
method='POST',
|
|
2888
|
+
auth_type='Anonymous',
|
|
2889
|
+
style='RPC',
|
|
2890
|
+
req_body_type='formData',
|
|
2891
|
+
body_type='json'
|
|
2892
|
+
)
|
|
2893
|
+
return TeaCore.from_map(
|
|
2894
|
+
ecd_20201002_models.StartDesktopsResponse(),
|
|
2895
|
+
self.call_api(params, req, runtime)
|
|
2896
|
+
)
|
|
2897
|
+
|
|
2898
|
+
async def start_desktops_with_options_async(
|
|
2899
|
+
self,
|
|
2900
|
+
request: ecd_20201002_models.StartDesktopsRequest,
|
|
2901
|
+
runtime: util_models.RuntimeOptions,
|
|
2902
|
+
) -> ecd_20201002_models.StartDesktopsResponse:
|
|
2903
|
+
"""
|
|
2904
|
+
@summary Start cloud computers.
|
|
2905
|
+
|
|
2906
|
+
@description The cloud computers that you want to start must be in the Stopped state. After you call this operation, the cloud computers enter the Running state.
|
|
2907
|
+
|
|
2908
|
+
@param request: StartDesktopsRequest
|
|
2909
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2910
|
+
@return: StartDesktopsResponse
|
|
2911
|
+
"""
|
|
2912
|
+
UtilClient.validate_model(request)
|
|
2913
|
+
query = {}
|
|
2914
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2915
|
+
query['ClientId'] = request.client_id
|
|
2916
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2917
|
+
query['ClientOS'] = request.client_os
|
|
2918
|
+
if not UtilClient.is_unset(request.client_token):
|
|
2919
|
+
query['ClientToken'] = request.client_token
|
|
2920
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2921
|
+
query['ClientVersion'] = request.client_version
|
|
2922
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
2923
|
+
query['DesktopId'] = request.desktop_id
|
|
2924
|
+
if not UtilClient.is_unset(request.login_token):
|
|
2925
|
+
query['LoginToken'] = request.login_token
|
|
2926
|
+
if not UtilClient.is_unset(request.region_id):
|
|
2927
|
+
query['RegionId'] = request.region_id
|
|
2928
|
+
if not UtilClient.is_unset(request.session_id):
|
|
2929
|
+
query['SessionId'] = request.session_id
|
|
2930
|
+
if not UtilClient.is_unset(request.uuid):
|
|
2931
|
+
query['Uuid'] = request.uuid
|
|
2932
|
+
req = open_api_models.OpenApiRequest(
|
|
2933
|
+
query=OpenApiUtilClient.query(query)
|
|
2934
|
+
)
|
|
2935
|
+
params = open_api_models.Params(
|
|
2936
|
+
action='StartDesktops',
|
|
2937
|
+
version='2020-10-02',
|
|
2938
|
+
protocol='HTTPS',
|
|
2939
|
+
pathname='/',
|
|
2940
|
+
method='POST',
|
|
2941
|
+
auth_type='Anonymous',
|
|
2942
|
+
style='RPC',
|
|
2943
|
+
req_body_type='formData',
|
|
2944
|
+
body_type='json'
|
|
2945
|
+
)
|
|
2946
|
+
return TeaCore.from_map(
|
|
2947
|
+
ecd_20201002_models.StartDesktopsResponse(),
|
|
2948
|
+
await self.call_api_async(params, req, runtime)
|
|
2949
|
+
)
|
|
2950
|
+
|
|
2951
|
+
def start_desktops(
|
|
2952
|
+
self,
|
|
2953
|
+
request: ecd_20201002_models.StartDesktopsRequest,
|
|
2954
|
+
) -> ecd_20201002_models.StartDesktopsResponse:
|
|
2955
|
+
"""
|
|
2956
|
+
@summary Start cloud computers.
|
|
2957
|
+
|
|
2958
|
+
@description The cloud computers that you want to start must be in the Stopped state. After you call this operation, the cloud computers enter the Running state.
|
|
2959
|
+
|
|
2960
|
+
@param request: StartDesktopsRequest
|
|
2961
|
+
@return: StartDesktopsResponse
|
|
2962
|
+
"""
|
|
2963
|
+
runtime = util_models.RuntimeOptions()
|
|
2964
|
+
return self.start_desktops_with_options(request, runtime)
|
|
2965
|
+
|
|
2966
|
+
async def start_desktops_async(
|
|
2967
|
+
self,
|
|
2968
|
+
request: ecd_20201002_models.StartDesktopsRequest,
|
|
2969
|
+
) -> ecd_20201002_models.StartDesktopsResponse:
|
|
2970
|
+
"""
|
|
2971
|
+
@summary Start cloud computers.
|
|
2972
|
+
|
|
2973
|
+
@description The cloud computers that you want to start must be in the Stopped state. After you call this operation, the cloud computers enter the Running state.
|
|
2974
|
+
|
|
2975
|
+
@param request: StartDesktopsRequest
|
|
2976
|
+
@return: StartDesktopsResponse
|
|
2977
|
+
"""
|
|
2978
|
+
runtime = util_models.RuntimeOptions()
|
|
2979
|
+
return await self.start_desktops_with_options_async(request, runtime)
|
|
2980
|
+
|
|
2981
|
+
def start_record_content_with_options(
|
|
2982
|
+
self,
|
|
2983
|
+
request: ecd_20201002_models.StartRecordContentRequest,
|
|
2984
|
+
runtime: util_models.RuntimeOptions,
|
|
2985
|
+
) -> ecd_20201002_models.StartRecordContentResponse:
|
|
2986
|
+
"""
|
|
2987
|
+
@param request: StartRecordContentRequest
|
|
2988
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
2989
|
+
@return: StartRecordContentResponse
|
|
2990
|
+
"""
|
|
2991
|
+
UtilClient.validate_model(request)
|
|
2992
|
+
query = {}
|
|
2993
|
+
if not UtilClient.is_unset(request.client_id):
|
|
2994
|
+
query['ClientId'] = request.client_id
|
|
2995
|
+
if not UtilClient.is_unset(request.client_os):
|
|
2996
|
+
query['ClientOS'] = request.client_os
|
|
2997
|
+
if not UtilClient.is_unset(request.client_version):
|
|
2998
|
+
query['ClientVersion'] = request.client_version
|
|
2999
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
3000
|
+
query['DesktopId'] = request.desktop_id
|
|
3001
|
+
if not UtilClient.is_unset(request.file_path):
|
|
3002
|
+
query['FilePath'] = request.file_path
|
|
3003
|
+
if not UtilClient.is_unset(request.login_token):
|
|
3004
|
+
query['LoginToken'] = request.login_token
|
|
3005
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3006
|
+
query['RegionId'] = request.region_id
|
|
3007
|
+
if not UtilClient.is_unset(request.session_id):
|
|
3008
|
+
query['SessionId'] = request.session_id
|
|
3009
|
+
req = open_api_models.OpenApiRequest(
|
|
3010
|
+
query=OpenApiUtilClient.query(query)
|
|
3011
|
+
)
|
|
3012
|
+
params = open_api_models.Params(
|
|
3013
|
+
action='StartRecordContent',
|
|
3014
|
+
version='2020-10-02',
|
|
3015
|
+
protocol='HTTPS',
|
|
3016
|
+
pathname='/',
|
|
3017
|
+
method='POST',
|
|
3018
|
+
auth_type='Anonymous',
|
|
3019
|
+
style='RPC',
|
|
3020
|
+
req_body_type='formData',
|
|
3021
|
+
body_type='json'
|
|
3022
|
+
)
|
|
3023
|
+
return TeaCore.from_map(
|
|
3024
|
+
ecd_20201002_models.StartRecordContentResponse(),
|
|
3025
|
+
self.call_api(params, req, runtime)
|
|
3026
|
+
)
|
|
3027
|
+
|
|
3028
|
+
async def start_record_content_with_options_async(
|
|
3029
|
+
self,
|
|
3030
|
+
request: ecd_20201002_models.StartRecordContentRequest,
|
|
3031
|
+
runtime: util_models.RuntimeOptions,
|
|
3032
|
+
) -> ecd_20201002_models.StartRecordContentResponse:
|
|
3033
|
+
"""
|
|
3034
|
+
@param request: StartRecordContentRequest
|
|
3035
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3036
|
+
@return: StartRecordContentResponse
|
|
3037
|
+
"""
|
|
3038
|
+
UtilClient.validate_model(request)
|
|
3039
|
+
query = {}
|
|
3040
|
+
if not UtilClient.is_unset(request.client_id):
|
|
3041
|
+
query['ClientId'] = request.client_id
|
|
3042
|
+
if not UtilClient.is_unset(request.client_os):
|
|
3043
|
+
query['ClientOS'] = request.client_os
|
|
3044
|
+
if not UtilClient.is_unset(request.client_version):
|
|
3045
|
+
query['ClientVersion'] = request.client_version
|
|
3046
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
3047
|
+
query['DesktopId'] = request.desktop_id
|
|
3048
|
+
if not UtilClient.is_unset(request.file_path):
|
|
3049
|
+
query['FilePath'] = request.file_path
|
|
3050
|
+
if not UtilClient.is_unset(request.login_token):
|
|
3051
|
+
query['LoginToken'] = request.login_token
|
|
3052
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3053
|
+
query['RegionId'] = request.region_id
|
|
3054
|
+
if not UtilClient.is_unset(request.session_id):
|
|
3055
|
+
query['SessionId'] = request.session_id
|
|
3056
|
+
req = open_api_models.OpenApiRequest(
|
|
3057
|
+
query=OpenApiUtilClient.query(query)
|
|
3058
|
+
)
|
|
3059
|
+
params = open_api_models.Params(
|
|
3060
|
+
action='StartRecordContent',
|
|
3061
|
+
version='2020-10-02',
|
|
3062
|
+
protocol='HTTPS',
|
|
3063
|
+
pathname='/',
|
|
3064
|
+
method='POST',
|
|
3065
|
+
auth_type='Anonymous',
|
|
3066
|
+
style='RPC',
|
|
3067
|
+
req_body_type='formData',
|
|
3068
|
+
body_type='json'
|
|
3069
|
+
)
|
|
3070
|
+
return TeaCore.from_map(
|
|
3071
|
+
ecd_20201002_models.StartRecordContentResponse(),
|
|
3072
|
+
await self.call_api_async(params, req, runtime)
|
|
3073
|
+
)
|
|
3074
|
+
|
|
3075
|
+
def start_record_content(
|
|
3076
|
+
self,
|
|
3077
|
+
request: ecd_20201002_models.StartRecordContentRequest,
|
|
3078
|
+
) -> ecd_20201002_models.StartRecordContentResponse:
|
|
3079
|
+
"""
|
|
3080
|
+
@param request: StartRecordContentRequest
|
|
3081
|
+
@return: StartRecordContentResponse
|
|
3082
|
+
"""
|
|
3083
|
+
runtime = util_models.RuntimeOptions()
|
|
3084
|
+
return self.start_record_content_with_options(request, runtime)
|
|
3085
|
+
|
|
3086
|
+
async def start_record_content_async(
|
|
3087
|
+
self,
|
|
3088
|
+
request: ecd_20201002_models.StartRecordContentRequest,
|
|
3089
|
+
) -> ecd_20201002_models.StartRecordContentResponse:
|
|
3090
|
+
"""
|
|
3091
|
+
@param request: StartRecordContentRequest
|
|
3092
|
+
@return: StartRecordContentResponse
|
|
3093
|
+
"""
|
|
3094
|
+
runtime = util_models.RuntimeOptions()
|
|
3095
|
+
return await self.start_record_content_with_options_async(request, runtime)
|
|
3096
|
+
|
|
3097
|
+
def stop_desktops_with_options(
|
|
3098
|
+
self,
|
|
3099
|
+
request: ecd_20201002_models.StopDesktopsRequest,
|
|
3100
|
+
runtime: util_models.RuntimeOptions,
|
|
3101
|
+
) -> ecd_20201002_models.StopDesktopsResponse:
|
|
3102
|
+
"""
|
|
3103
|
+
@summary Stops cloud computers.
|
|
3104
|
+
|
|
3105
|
+
@description The cloud computers that you want to stop must be in the Running state. After you call this operation, the cloud computers enter the Stopped state.
|
|
3106
|
+
|
|
3107
|
+
@param request: StopDesktopsRequest
|
|
3108
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3109
|
+
@return: StopDesktopsResponse
|
|
3110
|
+
"""
|
|
3111
|
+
UtilClient.validate_model(request)
|
|
3112
|
+
query = {}
|
|
3113
|
+
if not UtilClient.is_unset(request.client_id):
|
|
3114
|
+
query['ClientId'] = request.client_id
|
|
3115
|
+
if not UtilClient.is_unset(request.client_os):
|
|
3116
|
+
query['ClientOS'] = request.client_os
|
|
3117
|
+
if not UtilClient.is_unset(request.client_token):
|
|
3118
|
+
query['ClientToken'] = request.client_token
|
|
3119
|
+
if not UtilClient.is_unset(request.client_version):
|
|
3120
|
+
query['ClientVersion'] = request.client_version
|
|
3121
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
3122
|
+
query['DesktopId'] = request.desktop_id
|
|
3123
|
+
if not UtilClient.is_unset(request.login_token):
|
|
3124
|
+
query['LoginToken'] = request.login_token
|
|
3125
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3126
|
+
query['RegionId'] = request.region_id
|
|
3127
|
+
if not UtilClient.is_unset(request.session_id):
|
|
3128
|
+
query['SessionId'] = request.session_id
|
|
3129
|
+
if not UtilClient.is_unset(request.session_token):
|
|
3130
|
+
query['SessionToken'] = request.session_token
|
|
3131
|
+
req = open_api_models.OpenApiRequest(
|
|
3132
|
+
query=OpenApiUtilClient.query(query)
|
|
3133
|
+
)
|
|
3134
|
+
params = open_api_models.Params(
|
|
3135
|
+
action='StopDesktops',
|
|
3136
|
+
version='2020-10-02',
|
|
3137
|
+
protocol='HTTPS',
|
|
3138
|
+
pathname='/',
|
|
3139
|
+
method='POST',
|
|
3140
|
+
auth_type='Anonymous',
|
|
3141
|
+
style='RPC',
|
|
3142
|
+
req_body_type='formData',
|
|
3143
|
+
body_type='json'
|
|
3144
|
+
)
|
|
3145
|
+
return TeaCore.from_map(
|
|
3146
|
+
ecd_20201002_models.StopDesktopsResponse(),
|
|
3147
|
+
self.call_api(params, req, runtime)
|
|
3148
|
+
)
|
|
3149
|
+
|
|
3150
|
+
async def stop_desktops_with_options_async(
|
|
3151
|
+
self,
|
|
3152
|
+
request: ecd_20201002_models.StopDesktopsRequest,
|
|
3153
|
+
runtime: util_models.RuntimeOptions,
|
|
3154
|
+
) -> ecd_20201002_models.StopDesktopsResponse:
|
|
3155
|
+
"""
|
|
3156
|
+
@summary Stops cloud computers.
|
|
3157
|
+
|
|
3158
|
+
@description The cloud computers that you want to stop must be in the Running state. After you call this operation, the cloud computers enter the Stopped state.
|
|
3159
|
+
|
|
3160
|
+
@param request: StopDesktopsRequest
|
|
3161
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3162
|
+
@return: StopDesktopsResponse
|
|
3163
|
+
"""
|
|
3164
|
+
UtilClient.validate_model(request)
|
|
3165
|
+
query = {}
|
|
3166
|
+
if not UtilClient.is_unset(request.client_id):
|
|
3167
|
+
query['ClientId'] = request.client_id
|
|
3168
|
+
if not UtilClient.is_unset(request.client_os):
|
|
3169
|
+
query['ClientOS'] = request.client_os
|
|
3170
|
+
if not UtilClient.is_unset(request.client_token):
|
|
3171
|
+
query['ClientToken'] = request.client_token
|
|
3172
|
+
if not UtilClient.is_unset(request.client_version):
|
|
3173
|
+
query['ClientVersion'] = request.client_version
|
|
3174
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
3175
|
+
query['DesktopId'] = request.desktop_id
|
|
3176
|
+
if not UtilClient.is_unset(request.login_token):
|
|
3177
|
+
query['LoginToken'] = request.login_token
|
|
3178
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3179
|
+
query['RegionId'] = request.region_id
|
|
3180
|
+
if not UtilClient.is_unset(request.session_id):
|
|
3181
|
+
query['SessionId'] = request.session_id
|
|
3182
|
+
if not UtilClient.is_unset(request.session_token):
|
|
3183
|
+
query['SessionToken'] = request.session_token
|
|
3184
|
+
req = open_api_models.OpenApiRequest(
|
|
3185
|
+
query=OpenApiUtilClient.query(query)
|
|
3186
|
+
)
|
|
3187
|
+
params = open_api_models.Params(
|
|
3188
|
+
action='StopDesktops',
|
|
3189
|
+
version='2020-10-02',
|
|
3190
|
+
protocol='HTTPS',
|
|
3191
|
+
pathname='/',
|
|
3192
|
+
method='POST',
|
|
3193
|
+
auth_type='Anonymous',
|
|
3194
|
+
style='RPC',
|
|
3195
|
+
req_body_type='formData',
|
|
3196
|
+
body_type='json'
|
|
3197
|
+
)
|
|
3198
|
+
return TeaCore.from_map(
|
|
3199
|
+
ecd_20201002_models.StopDesktopsResponse(),
|
|
3200
|
+
await self.call_api_async(params, req, runtime)
|
|
3201
|
+
)
|
|
3202
|
+
|
|
3203
|
+
def stop_desktops(
|
|
3204
|
+
self,
|
|
3205
|
+
request: ecd_20201002_models.StopDesktopsRequest,
|
|
3206
|
+
) -> ecd_20201002_models.StopDesktopsResponse:
|
|
3207
|
+
"""
|
|
3208
|
+
@summary Stops cloud computers.
|
|
3209
|
+
|
|
3210
|
+
@description The cloud computers that you want to stop must be in the Running state. After you call this operation, the cloud computers enter the Stopped state.
|
|
3211
|
+
|
|
3212
|
+
@param request: StopDesktopsRequest
|
|
3213
|
+
@return: StopDesktopsResponse
|
|
3214
|
+
"""
|
|
3215
|
+
runtime = util_models.RuntimeOptions()
|
|
3216
|
+
return self.stop_desktops_with_options(request, runtime)
|
|
3217
|
+
|
|
3218
|
+
async def stop_desktops_async(
|
|
3219
|
+
self,
|
|
3220
|
+
request: ecd_20201002_models.StopDesktopsRequest,
|
|
3221
|
+
) -> ecd_20201002_models.StopDesktopsResponse:
|
|
3222
|
+
"""
|
|
3223
|
+
@summary Stops cloud computers.
|
|
3224
|
+
|
|
3225
|
+
@description The cloud computers that you want to stop must be in the Running state. After you call this operation, the cloud computers enter the Stopped state.
|
|
3226
|
+
|
|
3227
|
+
@param request: StopDesktopsRequest
|
|
3228
|
+
@return: StopDesktopsResponse
|
|
3229
|
+
"""
|
|
3230
|
+
runtime = util_models.RuntimeOptions()
|
|
3231
|
+
return await self.stop_desktops_with_options_async(request, runtime)
|
|
3232
|
+
|
|
3233
|
+
def stop_record_content_with_options(
|
|
3234
|
+
self,
|
|
3235
|
+
request: ecd_20201002_models.StopRecordContentRequest,
|
|
3236
|
+
runtime: util_models.RuntimeOptions,
|
|
3237
|
+
) -> ecd_20201002_models.StopRecordContentResponse:
|
|
3238
|
+
"""
|
|
3239
|
+
@param request: StopRecordContentRequest
|
|
3240
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3241
|
+
@return: StopRecordContentResponse
|
|
3242
|
+
"""
|
|
3243
|
+
UtilClient.validate_model(request)
|
|
3244
|
+
query = {}
|
|
3245
|
+
if not UtilClient.is_unset(request.client_id):
|
|
3246
|
+
query['ClientId'] = request.client_id
|
|
3247
|
+
if not UtilClient.is_unset(request.client_os):
|
|
3248
|
+
query['ClientOS'] = request.client_os
|
|
3249
|
+
if not UtilClient.is_unset(request.client_version):
|
|
3250
|
+
query['ClientVersion'] = request.client_version
|
|
3251
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
3252
|
+
query['DesktopId'] = request.desktop_id
|
|
3253
|
+
if not UtilClient.is_unset(request.login_token):
|
|
3254
|
+
query['LoginToken'] = request.login_token
|
|
3255
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3256
|
+
query['RegionId'] = request.region_id
|
|
3257
|
+
if not UtilClient.is_unset(request.session_id):
|
|
3258
|
+
query['SessionId'] = request.session_id
|
|
3259
|
+
req = open_api_models.OpenApiRequest(
|
|
3260
|
+
query=OpenApiUtilClient.query(query)
|
|
3261
|
+
)
|
|
3262
|
+
params = open_api_models.Params(
|
|
3263
|
+
action='StopRecordContent',
|
|
3264
|
+
version='2020-10-02',
|
|
3265
|
+
protocol='HTTPS',
|
|
3266
|
+
pathname='/',
|
|
3267
|
+
method='POST',
|
|
3268
|
+
auth_type='Anonymous',
|
|
3269
|
+
style='RPC',
|
|
3270
|
+
req_body_type='formData',
|
|
3271
|
+
body_type='json'
|
|
3272
|
+
)
|
|
3273
|
+
return TeaCore.from_map(
|
|
3274
|
+
ecd_20201002_models.StopRecordContentResponse(),
|
|
3275
|
+
self.call_api(params, req, runtime)
|
|
3276
|
+
)
|
|
3277
|
+
|
|
3278
|
+
async def stop_record_content_with_options_async(
|
|
3279
|
+
self,
|
|
3280
|
+
request: ecd_20201002_models.StopRecordContentRequest,
|
|
3281
|
+
runtime: util_models.RuntimeOptions,
|
|
3282
|
+
) -> ecd_20201002_models.StopRecordContentResponse:
|
|
3283
|
+
"""
|
|
3284
|
+
@param request: StopRecordContentRequest
|
|
3285
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3286
|
+
@return: StopRecordContentResponse
|
|
3287
|
+
"""
|
|
3288
|
+
UtilClient.validate_model(request)
|
|
3289
|
+
query = {}
|
|
3290
|
+
if not UtilClient.is_unset(request.client_id):
|
|
3291
|
+
query['ClientId'] = request.client_id
|
|
3292
|
+
if not UtilClient.is_unset(request.client_os):
|
|
3293
|
+
query['ClientOS'] = request.client_os
|
|
3294
|
+
if not UtilClient.is_unset(request.client_version):
|
|
3295
|
+
query['ClientVersion'] = request.client_version
|
|
3296
|
+
if not UtilClient.is_unset(request.desktop_id):
|
|
3297
|
+
query['DesktopId'] = request.desktop_id
|
|
3298
|
+
if not UtilClient.is_unset(request.login_token):
|
|
3299
|
+
query['LoginToken'] = request.login_token
|
|
3300
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3301
|
+
query['RegionId'] = request.region_id
|
|
3302
|
+
if not UtilClient.is_unset(request.session_id):
|
|
3303
|
+
query['SessionId'] = request.session_id
|
|
3304
|
+
req = open_api_models.OpenApiRequest(
|
|
3305
|
+
query=OpenApiUtilClient.query(query)
|
|
3306
|
+
)
|
|
3307
|
+
params = open_api_models.Params(
|
|
3308
|
+
action='StopRecordContent',
|
|
3309
|
+
version='2020-10-02',
|
|
3310
|
+
protocol='HTTPS',
|
|
3311
|
+
pathname='/',
|
|
3312
|
+
method='POST',
|
|
3313
|
+
auth_type='Anonymous',
|
|
3314
|
+
style='RPC',
|
|
3315
|
+
req_body_type='formData',
|
|
3316
|
+
body_type='json'
|
|
3317
|
+
)
|
|
3318
|
+
return TeaCore.from_map(
|
|
3319
|
+
ecd_20201002_models.StopRecordContentResponse(),
|
|
3320
|
+
await self.call_api_async(params, req, runtime)
|
|
3321
|
+
)
|
|
3322
|
+
|
|
3323
|
+
def stop_record_content(
|
|
3324
|
+
self,
|
|
3325
|
+
request: ecd_20201002_models.StopRecordContentRequest,
|
|
3326
|
+
) -> ecd_20201002_models.StopRecordContentResponse:
|
|
3327
|
+
"""
|
|
3328
|
+
@param request: StopRecordContentRequest
|
|
3329
|
+
@return: StopRecordContentResponse
|
|
3330
|
+
"""
|
|
3331
|
+
runtime = util_models.RuntimeOptions()
|
|
3332
|
+
return self.stop_record_content_with_options(request, runtime)
|
|
3333
|
+
|
|
3334
|
+
async def stop_record_content_async(
|
|
3335
|
+
self,
|
|
3336
|
+
request: ecd_20201002_models.StopRecordContentRequest,
|
|
3337
|
+
) -> ecd_20201002_models.StopRecordContentResponse:
|
|
3338
|
+
"""
|
|
3339
|
+
@param request: StopRecordContentRequest
|
|
3340
|
+
@return: StopRecordContentResponse
|
|
3341
|
+
"""
|
|
3342
|
+
runtime = util_models.RuntimeOptions()
|
|
3343
|
+
return await self.stop_record_content_with_options_async(request, runtime)
|
|
3344
|
+
|
|
3345
|
+
def unbind_user_desktop_with_options(
|
|
3346
|
+
self,
|
|
3347
|
+
request: ecd_20201002_models.UnbindUserDesktopRequest,
|
|
3348
|
+
runtime: util_models.RuntimeOptions,
|
|
3349
|
+
) -> ecd_20201002_models.UnbindUserDesktopResponse:
|
|
3350
|
+
"""
|
|
3351
|
+
@summary 解绑用户桌面
|
|
3352
|
+
|
|
3353
|
+
@param request: UnbindUserDesktopRequest
|
|
3354
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3355
|
+
@return: UnbindUserDesktopResponse
|
|
3356
|
+
"""
|
|
3357
|
+
UtilClient.validate_model(request)
|
|
3358
|
+
query = {}
|
|
3359
|
+
if not UtilClient.is_unset(request.client_id):
|
|
3360
|
+
query['ClientId'] = request.client_id
|
|
3361
|
+
if not UtilClient.is_unset(request.client_type):
|
|
3362
|
+
query['ClientType'] = request.client_type
|
|
3363
|
+
if not UtilClient.is_unset(request.force):
|
|
3364
|
+
query['Force'] = request.force
|
|
3365
|
+
if not UtilClient.is_unset(request.login_token):
|
|
3366
|
+
query['LoginToken'] = request.login_token
|
|
3367
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3368
|
+
query['RegionId'] = request.region_id
|
|
3369
|
+
if not UtilClient.is_unset(request.session_id):
|
|
3370
|
+
query['SessionId'] = request.session_id
|
|
3371
|
+
if not UtilClient.is_unset(request.user_desktop_id):
|
|
3372
|
+
query['UserDesktopId'] = request.user_desktop_id
|
|
3373
|
+
req = open_api_models.OpenApiRequest(
|
|
3374
|
+
query=OpenApiUtilClient.query(query)
|
|
3375
|
+
)
|
|
3376
|
+
params = open_api_models.Params(
|
|
3377
|
+
action='UnbindUserDesktop',
|
|
3378
|
+
version='2020-10-02',
|
|
3379
|
+
protocol='HTTPS',
|
|
3380
|
+
pathname='/',
|
|
3381
|
+
method='POST',
|
|
3382
|
+
auth_type='Anonymous',
|
|
3383
|
+
style='RPC',
|
|
3384
|
+
req_body_type='formData',
|
|
3385
|
+
body_type='json'
|
|
3386
|
+
)
|
|
3387
|
+
return TeaCore.from_map(
|
|
3388
|
+
ecd_20201002_models.UnbindUserDesktopResponse(),
|
|
3389
|
+
self.call_api(params, req, runtime)
|
|
3390
|
+
)
|
|
3391
|
+
|
|
3392
|
+
async def unbind_user_desktop_with_options_async(
|
|
3393
|
+
self,
|
|
3394
|
+
request: ecd_20201002_models.UnbindUserDesktopRequest,
|
|
3395
|
+
runtime: util_models.RuntimeOptions,
|
|
3396
|
+
) -> ecd_20201002_models.UnbindUserDesktopResponse:
|
|
3397
|
+
"""
|
|
3398
|
+
@summary 解绑用户桌面
|
|
3399
|
+
|
|
3400
|
+
@param request: UnbindUserDesktopRequest
|
|
3401
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3402
|
+
@return: UnbindUserDesktopResponse
|
|
3403
|
+
"""
|
|
3404
|
+
UtilClient.validate_model(request)
|
|
3405
|
+
query = {}
|
|
3406
|
+
if not UtilClient.is_unset(request.client_id):
|
|
3407
|
+
query['ClientId'] = request.client_id
|
|
3408
|
+
if not UtilClient.is_unset(request.client_type):
|
|
3409
|
+
query['ClientType'] = request.client_type
|
|
3410
|
+
if not UtilClient.is_unset(request.force):
|
|
3411
|
+
query['Force'] = request.force
|
|
3412
|
+
if not UtilClient.is_unset(request.login_token):
|
|
3413
|
+
query['LoginToken'] = request.login_token
|
|
3414
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3415
|
+
query['RegionId'] = request.region_id
|
|
3416
|
+
if not UtilClient.is_unset(request.session_id):
|
|
3417
|
+
query['SessionId'] = request.session_id
|
|
3418
|
+
if not UtilClient.is_unset(request.user_desktop_id):
|
|
3419
|
+
query['UserDesktopId'] = request.user_desktop_id
|
|
3420
|
+
req = open_api_models.OpenApiRequest(
|
|
3421
|
+
query=OpenApiUtilClient.query(query)
|
|
3422
|
+
)
|
|
3423
|
+
params = open_api_models.Params(
|
|
3424
|
+
action='UnbindUserDesktop',
|
|
3425
|
+
version='2020-10-02',
|
|
3426
|
+
protocol='HTTPS',
|
|
3427
|
+
pathname='/',
|
|
3428
|
+
method='POST',
|
|
3429
|
+
auth_type='Anonymous',
|
|
3430
|
+
style='RPC',
|
|
3431
|
+
req_body_type='formData',
|
|
3432
|
+
body_type='json'
|
|
3433
|
+
)
|
|
3434
|
+
return TeaCore.from_map(
|
|
3435
|
+
ecd_20201002_models.UnbindUserDesktopResponse(),
|
|
3436
|
+
await self.call_api_async(params, req, runtime)
|
|
3437
|
+
)
|
|
3438
|
+
|
|
3439
|
+
def unbind_user_desktop(
|
|
3440
|
+
self,
|
|
3441
|
+
request: ecd_20201002_models.UnbindUserDesktopRequest,
|
|
3442
|
+
) -> ecd_20201002_models.UnbindUserDesktopResponse:
|
|
3443
|
+
"""
|
|
3444
|
+
@summary 解绑用户桌面
|
|
3445
|
+
|
|
3446
|
+
@param request: UnbindUserDesktopRequest
|
|
3447
|
+
@return: UnbindUserDesktopResponse
|
|
3448
|
+
"""
|
|
3449
|
+
runtime = util_models.RuntimeOptions()
|
|
3450
|
+
return self.unbind_user_desktop_with_options(request, runtime)
|
|
3451
|
+
|
|
3452
|
+
async def unbind_user_desktop_async(
|
|
3453
|
+
self,
|
|
3454
|
+
request: ecd_20201002_models.UnbindUserDesktopRequest,
|
|
3455
|
+
) -> ecd_20201002_models.UnbindUserDesktopResponse:
|
|
3456
|
+
"""
|
|
3457
|
+
@summary 解绑用户桌面
|
|
3458
|
+
|
|
3459
|
+
@param request: UnbindUserDesktopRequest
|
|
3460
|
+
@return: UnbindUserDesktopResponse
|
|
3461
|
+
"""
|
|
3462
|
+
runtime = util_models.RuntimeOptions()
|
|
3463
|
+
return await self.unbind_user_desktop_with_options_async(request, runtime)
|
|
3464
|
+
|
|
3465
|
+
def verify_credential_with_options(
|
|
3466
|
+
self,
|
|
3467
|
+
request: ecd_20201002_models.VerifyCredentialRequest,
|
|
3468
|
+
runtime: util_models.RuntimeOptions,
|
|
3469
|
+
) -> ecd_20201002_models.VerifyCredentialResponse:
|
|
3470
|
+
"""
|
|
3471
|
+
@param request: VerifyCredentialRequest
|
|
3472
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3473
|
+
@return: VerifyCredentialResponse
|
|
3474
|
+
"""
|
|
3475
|
+
UtilClient.validate_model(request)
|
|
3476
|
+
query = {}
|
|
3477
|
+
if not UtilClient.is_unset(request.client_id):
|
|
3478
|
+
query['ClientId'] = request.client_id
|
|
3479
|
+
if not UtilClient.is_unset(request.credential):
|
|
3480
|
+
query['Credential'] = request.credential
|
|
3481
|
+
if not UtilClient.is_unset(request.credential_type):
|
|
3482
|
+
query['CredentialType'] = request.credential_type
|
|
3483
|
+
if not UtilClient.is_unset(request.encrypted_key):
|
|
3484
|
+
query['EncryptedKey'] = request.encrypted_key
|
|
3485
|
+
if not UtilClient.is_unset(request.login_token):
|
|
3486
|
+
query['LoginToken'] = request.login_token
|
|
3487
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
3488
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
3489
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3490
|
+
query['RegionId'] = request.region_id
|
|
3491
|
+
if not UtilClient.is_unset(request.session_id):
|
|
3492
|
+
query['SessionId'] = request.session_id
|
|
3493
|
+
req = open_api_models.OpenApiRequest(
|
|
3494
|
+
query=OpenApiUtilClient.query(query)
|
|
3495
|
+
)
|
|
3496
|
+
params = open_api_models.Params(
|
|
3497
|
+
action='VerifyCredential',
|
|
3498
|
+
version='2020-10-02',
|
|
3499
|
+
protocol='HTTPS',
|
|
3500
|
+
pathname='/',
|
|
3501
|
+
method='POST',
|
|
3502
|
+
auth_type='Anonymous',
|
|
3503
|
+
style='RPC',
|
|
3504
|
+
req_body_type='formData',
|
|
3505
|
+
body_type='json'
|
|
3506
|
+
)
|
|
3507
|
+
return TeaCore.from_map(
|
|
3508
|
+
ecd_20201002_models.VerifyCredentialResponse(),
|
|
3509
|
+
self.call_api(params, req, runtime)
|
|
3510
|
+
)
|
|
3511
|
+
|
|
3512
|
+
async def verify_credential_with_options_async(
|
|
3513
|
+
self,
|
|
3514
|
+
request: ecd_20201002_models.VerifyCredentialRequest,
|
|
3515
|
+
runtime: util_models.RuntimeOptions,
|
|
3516
|
+
) -> ecd_20201002_models.VerifyCredentialResponse:
|
|
3517
|
+
"""
|
|
3518
|
+
@param request: VerifyCredentialRequest
|
|
3519
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3520
|
+
@return: VerifyCredentialResponse
|
|
3521
|
+
"""
|
|
3522
|
+
UtilClient.validate_model(request)
|
|
3523
|
+
query = {}
|
|
3524
|
+
if not UtilClient.is_unset(request.client_id):
|
|
3525
|
+
query['ClientId'] = request.client_id
|
|
3526
|
+
if not UtilClient.is_unset(request.credential):
|
|
3527
|
+
query['Credential'] = request.credential
|
|
3528
|
+
if not UtilClient.is_unset(request.credential_type):
|
|
3529
|
+
query['CredentialType'] = request.credential_type
|
|
3530
|
+
if not UtilClient.is_unset(request.encrypted_key):
|
|
3531
|
+
query['EncryptedKey'] = request.encrypted_key
|
|
3532
|
+
if not UtilClient.is_unset(request.login_token):
|
|
3533
|
+
query['LoginToken'] = request.login_token
|
|
3534
|
+
if not UtilClient.is_unset(request.office_site_id):
|
|
3535
|
+
query['OfficeSiteId'] = request.office_site_id
|
|
3536
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3537
|
+
query['RegionId'] = request.region_id
|
|
3538
|
+
if not UtilClient.is_unset(request.session_id):
|
|
3539
|
+
query['SessionId'] = request.session_id
|
|
3540
|
+
req = open_api_models.OpenApiRequest(
|
|
3541
|
+
query=OpenApiUtilClient.query(query)
|
|
3542
|
+
)
|
|
3543
|
+
params = open_api_models.Params(
|
|
3544
|
+
action='VerifyCredential',
|
|
3545
|
+
version='2020-10-02',
|
|
3546
|
+
protocol='HTTPS',
|
|
3547
|
+
pathname='/',
|
|
3548
|
+
method='POST',
|
|
3549
|
+
auth_type='Anonymous',
|
|
3550
|
+
style='RPC',
|
|
3551
|
+
req_body_type='formData',
|
|
3552
|
+
body_type='json'
|
|
3553
|
+
)
|
|
3554
|
+
return TeaCore.from_map(
|
|
3555
|
+
ecd_20201002_models.VerifyCredentialResponse(),
|
|
3556
|
+
await self.call_api_async(params, req, runtime)
|
|
3557
|
+
)
|
|
3558
|
+
|
|
3559
|
+
def verify_credential(
|
|
3560
|
+
self,
|
|
3561
|
+
request: ecd_20201002_models.VerifyCredentialRequest,
|
|
3562
|
+
) -> ecd_20201002_models.VerifyCredentialResponse:
|
|
3563
|
+
"""
|
|
3564
|
+
@param request: VerifyCredentialRequest
|
|
3565
|
+
@return: VerifyCredentialResponse
|
|
3566
|
+
"""
|
|
3567
|
+
runtime = util_models.RuntimeOptions()
|
|
3568
|
+
return self.verify_credential_with_options(request, runtime)
|
|
3569
|
+
|
|
3570
|
+
async def verify_credential_async(
|
|
3571
|
+
self,
|
|
3572
|
+
request: ecd_20201002_models.VerifyCredentialRequest,
|
|
3573
|
+
) -> ecd_20201002_models.VerifyCredentialResponse:
|
|
3574
|
+
"""
|
|
3575
|
+
@param request: VerifyCredentialRequest
|
|
3576
|
+
@return: VerifyCredentialResponse
|
|
3577
|
+
"""
|
|
3578
|
+
runtime = util_models.RuntimeOptions()
|
|
3579
|
+
return await self.verify_credential_with_options_async(request, runtime)
|