1761 lines
52 KiB
Python
1761 lines
52 KiB
Python
# -*- coding: utf-8 -*-
|
|
# This file is auto-generated, don't edit it. Thanks.
|
|
from Tea.model import TeaModel
|
|
from typing import Dict, List
|
|
|
|
|
|
class PrivateFieldMapValue(TeaModel):
|
|
def __init__(
|
|
self,
|
|
tip_title: str = None,
|
|
is_ding_send: bool = None,
|
|
is_read: bool = None,
|
|
button_status: str = None,
|
|
extension: Dict[str, str] = None,
|
|
):
|
|
self.tip_title = tip_title
|
|
self.is_ding_send = is_ding_send
|
|
self.is_read = is_read
|
|
self.button_status = button_status
|
|
self.extension = extension
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.tip_title is not None:
|
|
result['tipTitle'] = self.tip_title
|
|
if self.is_ding_send is not None:
|
|
result['isDingSend'] = self.is_ding_send
|
|
if self.is_read is not None:
|
|
result['isRead'] = self.is_read
|
|
if self.button_status is not None:
|
|
result['buttonStatus'] = self.button_status
|
|
if self.extension is not None:
|
|
result['extension'] = self.extension
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('tipTitle') is not None:
|
|
self.tip_title = m.get('tipTitle')
|
|
if m.get('isDingSend') is not None:
|
|
self.is_ding_send = m.get('isDingSend')
|
|
if m.get('isRead') is not None:
|
|
self.is_read = m.get('isRead')
|
|
if m.get('buttonStatus') is not None:
|
|
self.button_status = m.get('buttonStatus')
|
|
if m.get('extension') is not None:
|
|
self.extension = m.get('extension')
|
|
return self
|
|
|
|
|
|
class AddPluginRuleHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class AddPluginRuleRequestRules(TeaModel):
|
|
def __init__(
|
|
self,
|
|
item_id: str = None,
|
|
item_name: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.item_id = item_id
|
|
# This parameter is required.
|
|
self.item_name = item_name
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.item_id is not None:
|
|
result['itemId'] = self.item_id
|
|
if self.item_name is not None:
|
|
result['itemName'] = self.item_name
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('itemId') is not None:
|
|
self.item_id = m.get('itemId')
|
|
if m.get('itemName') is not None:
|
|
self.item_name = m.get('itemName')
|
|
return self
|
|
|
|
|
|
class AddPluginRuleRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
chat_type: str = None,
|
|
code: str = None,
|
|
item_type: str = None,
|
|
rules: List[AddPluginRuleRequestRules] = None,
|
|
user_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.chat_type = chat_type
|
|
# This parameter is required.
|
|
self.code = code
|
|
# This parameter is required.
|
|
self.item_type = item_type
|
|
# This parameter is required.
|
|
self.rules = rules
|
|
# This parameter is required.
|
|
self.user_id = user_id
|
|
|
|
def validate(self):
|
|
if self.rules:
|
|
for k in self.rules:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.chat_type is not None:
|
|
result['chatType'] = self.chat_type
|
|
if self.code is not None:
|
|
result['code'] = self.code
|
|
if self.item_type is not None:
|
|
result['itemType'] = self.item_type
|
|
result['rules'] = []
|
|
if self.rules is not None:
|
|
for k in self.rules:
|
|
result['rules'].append(k.to_map() if k else None)
|
|
if self.user_id is not None:
|
|
result['userId'] = self.user_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('chatType') is not None:
|
|
self.chat_type = m.get('chatType')
|
|
if m.get('code') is not None:
|
|
self.code = m.get('code')
|
|
if m.get('itemType') is not None:
|
|
self.item_type = m.get('itemType')
|
|
self.rules = []
|
|
if m.get('rules') is not None:
|
|
for k in m.get('rules'):
|
|
temp_model = AddPluginRuleRequestRules()
|
|
self.rules.append(temp_model.from_map(k))
|
|
if m.get('userId') is not None:
|
|
self.user_id = m.get('userId')
|
|
return self
|
|
|
|
|
|
class AddPluginRuleResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
success: bool = None,
|
|
):
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.success is not None:
|
|
result['success'] = self.success
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class AddPluginRuleResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: AddPluginRuleResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = AddPluginRuleResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class DeletePlguinRuleHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class DeletePlguinRuleRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
biz_id_list: List[str] = None,
|
|
user_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.biz_id_list = biz_id_list
|
|
# This parameter is required.
|
|
self.user_id = user_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.biz_id_list is not None:
|
|
result['bizIdList'] = self.biz_id_list
|
|
if self.user_id is not None:
|
|
result['userId'] = self.user_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('bizIdList') is not None:
|
|
self.biz_id_list = m.get('bizIdList')
|
|
if m.get('userId') is not None:
|
|
self.user_id = m.get('userId')
|
|
return self
|
|
|
|
|
|
class DeletePlguinRuleResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
success: bool = None,
|
|
):
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.success is not None:
|
|
result['success'] = self.success
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class DeletePlguinRuleResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: DeletePlguinRuleResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = DeletePlguinRuleResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class GetBaseProfileListHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class GetBaseProfileListRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[str] = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.body is not None:
|
|
result['body'] = self.body
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('body') is not None:
|
|
self.body = m.get('body')
|
|
return self
|
|
|
|
|
|
class GetBaseProfileListResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
avatar_media_id: str = None,
|
|
nick: str = None,
|
|
nick_pinyin: str = None,
|
|
user_id: str = None,
|
|
):
|
|
self.avatar_media_id = avatar_media_id
|
|
self.nick = nick
|
|
self.nick_pinyin = nick_pinyin
|
|
self.user_id = user_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.avatar_media_id is not None:
|
|
result['avatarMediaId'] = self.avatar_media_id
|
|
if self.nick is not None:
|
|
result['nick'] = self.nick
|
|
if self.nick_pinyin is not None:
|
|
result['nickPinyin'] = self.nick_pinyin
|
|
if self.user_id is not None:
|
|
result['userId'] = self.user_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('avatarMediaId') is not None:
|
|
self.avatar_media_id = m.get('avatarMediaId')
|
|
if m.get('nick') is not None:
|
|
self.nick = m.get('nick')
|
|
if m.get('nickPinyin') is not None:
|
|
self.nick_pinyin = m.get('nickPinyin')
|
|
if m.get('userId') is not None:
|
|
self.user_id = m.get('userId')
|
|
return self
|
|
|
|
|
|
class GetBaseProfileListResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: List[GetBaseProfileListResponseBodyResult] = None,
|
|
success: bool = None,
|
|
):
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
if self.result:
|
|
for k in self.result:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['result'] = []
|
|
if self.result is not None:
|
|
for k in self.result:
|
|
result['result'].append(k.to_map() if k else None)
|
|
if self.success is not None:
|
|
result['success'] = self.success
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.result = []
|
|
if m.get('result') is not None:
|
|
for k in m.get('result'):
|
|
temp_model = GetBaseProfileListResponseBodyResult()
|
|
self.result.append(temp_model.from_map(k))
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class GetBaseProfileListResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: GetBaseProfileListResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = GetBaseProfileListResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class GetConversationHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class GetConversationRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
open_conversation_id: str = None,
|
|
user_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.open_conversation_id = open_conversation_id
|
|
self.user_id = user_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.open_conversation_id is not None:
|
|
result['openConversationId'] = self.open_conversation_id
|
|
if self.user_id is not None:
|
|
result['userId'] = self.user_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('openConversationId') is not None:
|
|
self.open_conversation_id = m.get('openConversationId')
|
|
if m.get('userId') is not None:
|
|
self.user_id = m.get('userId')
|
|
return self
|
|
|
|
|
|
class GetConversationResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
corp_id: str = None,
|
|
member_count: int = None,
|
|
title: str = None,
|
|
):
|
|
self.corp_id = corp_id
|
|
self.member_count = member_count
|
|
self.title = title
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
if self.member_count is not None:
|
|
result['memberCount'] = self.member_count
|
|
if self.title is not None:
|
|
result['title'] = self.title
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
if m.get('memberCount') is not None:
|
|
self.member_count = m.get('memberCount')
|
|
if m.get('title') is not None:
|
|
self.title = m.get('title')
|
|
return self
|
|
|
|
|
|
class GetConversationResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: GetConversationResponseBodyResult = None,
|
|
success: bool = None,
|
|
):
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
if self.result:
|
|
self.result.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.result is not None:
|
|
result['result'] = self.result.to_map()
|
|
if self.success is not None:
|
|
result['success'] = self.success
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('result') is not None:
|
|
temp_model = GetConversationResponseBodyResult()
|
|
self.result = temp_model.from_map(m['result'])
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class GetConversationResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: GetConversationResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = GetConversationResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class GetMemberListHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class GetMemberListRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
open_conversation_id: str = None,
|
|
page_number: int = None,
|
|
page_size: int = None,
|
|
user_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.open_conversation_id = open_conversation_id
|
|
# This parameter is required.
|
|
self.page_number = page_number
|
|
# This parameter is required.
|
|
self.page_size = page_size
|
|
self.user_id = user_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.open_conversation_id is not None:
|
|
result['openConversationId'] = self.open_conversation_id
|
|
if self.page_number is not None:
|
|
result['pageNumber'] = self.page_number
|
|
if self.page_size is not None:
|
|
result['pageSize'] = self.page_size
|
|
if self.user_id is not None:
|
|
result['userId'] = self.user_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('openConversationId') is not None:
|
|
self.open_conversation_id = m.get('openConversationId')
|
|
if m.get('pageNumber') is not None:
|
|
self.page_number = m.get('pageNumber')
|
|
if m.get('pageSize') is not None:
|
|
self.page_size = m.get('pageSize')
|
|
if m.get('userId') is not None:
|
|
self.user_id = m.get('userId')
|
|
return self
|
|
|
|
|
|
class GetMemberListResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: List[str] = None,
|
|
):
|
|
self.result = result
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
return self
|
|
|
|
|
|
class GetMemberListResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: GetMemberListResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = GetMemberListResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryPluginRuleHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class QueryPluginRuleRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
chat_type: str = None,
|
|
code: str = None,
|
|
item_id: str = None,
|
|
item_type: str = None,
|
|
page_number: int = None,
|
|
page_size: int = None,
|
|
):
|
|
self.chat_type = chat_type
|
|
self.code = code
|
|
self.item_id = item_id
|
|
self.item_type = item_type
|
|
# This parameter is required.
|
|
self.page_number = page_number
|
|
# This parameter is required.
|
|
self.page_size = page_size
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.chat_type is not None:
|
|
result['chatType'] = self.chat_type
|
|
if self.code is not None:
|
|
result['code'] = self.code
|
|
if self.item_id is not None:
|
|
result['itemId'] = self.item_id
|
|
if self.item_type is not None:
|
|
result['itemType'] = self.item_type
|
|
if self.page_number is not None:
|
|
result['pageNumber'] = self.page_number
|
|
if self.page_size is not None:
|
|
result['pageSize'] = self.page_size
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('chatType') is not None:
|
|
self.chat_type = m.get('chatType')
|
|
if m.get('code') is not None:
|
|
self.code = m.get('code')
|
|
if m.get('itemId') is not None:
|
|
self.item_id = m.get('itemId')
|
|
if m.get('itemType') is not None:
|
|
self.item_type = m.get('itemType')
|
|
if m.get('pageNumber') is not None:
|
|
self.page_number = m.get('pageNumber')
|
|
if m.get('pageSize') is not None:
|
|
self.page_size = m.get('pageSize')
|
|
return self
|
|
|
|
|
|
class QueryPluginRuleResponseBodyResultData(TeaModel):
|
|
def __init__(
|
|
self,
|
|
biz_id: str = None,
|
|
chat_type: str = None,
|
|
code: str = None,
|
|
gmt_create: str = None,
|
|
item_id: str = None,
|
|
item_name: str = None,
|
|
item_type: str = None,
|
|
):
|
|
self.biz_id = biz_id
|
|
self.chat_type = chat_type
|
|
self.code = code
|
|
self.gmt_create = gmt_create
|
|
self.item_id = item_id
|
|
self.item_name = item_name
|
|
self.item_type = item_type
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.biz_id is not None:
|
|
result['bizId'] = self.biz_id
|
|
if self.chat_type is not None:
|
|
result['chatType'] = self.chat_type
|
|
if self.code is not None:
|
|
result['code'] = self.code
|
|
if self.gmt_create is not None:
|
|
result['gmtCreate'] = self.gmt_create
|
|
if self.item_id is not None:
|
|
result['itemId'] = self.item_id
|
|
if self.item_name is not None:
|
|
result['itemName'] = self.item_name
|
|
if self.item_type is not None:
|
|
result['itemType'] = self.item_type
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('bizId') is not None:
|
|
self.biz_id = m.get('bizId')
|
|
if m.get('chatType') is not None:
|
|
self.chat_type = m.get('chatType')
|
|
if m.get('code') is not None:
|
|
self.code = m.get('code')
|
|
if m.get('gmtCreate') is not None:
|
|
self.gmt_create = m.get('gmtCreate')
|
|
if m.get('itemId') is not None:
|
|
self.item_id = m.get('itemId')
|
|
if m.get('itemName') is not None:
|
|
self.item_name = m.get('itemName')
|
|
if m.get('itemType') is not None:
|
|
self.item_type = m.get('itemType')
|
|
return self
|
|
|
|
|
|
class QueryPluginRuleResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
data: List[QueryPluginRuleResponseBodyResultData] = None,
|
|
total: int = None,
|
|
):
|
|
self.data = data
|
|
self.total = total
|
|
|
|
def validate(self):
|
|
if self.data:
|
|
for k in self.data:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['data'] = []
|
|
if self.data is not None:
|
|
for k in self.data:
|
|
result['data'].append(k.to_map() if k else None)
|
|
if self.total is not None:
|
|
result['total'] = self.total
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.data = []
|
|
if m.get('data') is not None:
|
|
for k in m.get('data'):
|
|
temp_model = QueryPluginRuleResponseBodyResultData()
|
|
self.data.append(temp_model.from_map(k))
|
|
if m.get('total') is not None:
|
|
self.total = m.get('total')
|
|
return self
|
|
|
|
|
|
class QueryPluginRuleResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: QueryPluginRuleResponseBodyResult = None,
|
|
success: bool = None,
|
|
):
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
if self.result:
|
|
self.result.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.result is not None:
|
|
result['result'] = self.result.to_map()
|
|
if self.success is not None:
|
|
result['success'] = self.success
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('result') is not None:
|
|
temp_model = QueryPluginRuleResponseBodyResult()
|
|
self.result = temp_model.from_map(m['result'])
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class QueryPluginRuleResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryPluginRuleResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = QueryPluginRuleResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class SendDingTipHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class SendDingTipRequestLink(TeaModel):
|
|
def __init__(
|
|
self,
|
|
extension: Dict[str, str] = None,
|
|
link_url: str = None,
|
|
pic_media_id: str = None,
|
|
text: str = None,
|
|
):
|
|
self.extension = extension
|
|
# This parameter is required.
|
|
self.link_url = link_url
|
|
self.pic_media_id = pic_media_id
|
|
# This parameter is required.
|
|
self.text = text
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.extension is not None:
|
|
result['extension'] = self.extension
|
|
if self.link_url is not None:
|
|
result['linkUrl'] = self.link_url
|
|
if self.pic_media_id is not None:
|
|
result['picMediaId'] = self.pic_media_id
|
|
if self.text is not None:
|
|
result['text'] = self.text
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('extension') is not None:
|
|
self.extension = m.get('extension')
|
|
if m.get('linkUrl') is not None:
|
|
self.link_url = m.get('linkUrl')
|
|
if m.get('picMediaId') is not None:
|
|
self.pic_media_id = m.get('picMediaId')
|
|
if m.get('text') is not None:
|
|
self.text = m.get('text')
|
|
return self
|
|
|
|
|
|
class SendDingTipRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
extension: Dict[str, str] = None,
|
|
link: SendDingTipRequestLink = None,
|
|
message_id: str = None,
|
|
receiver_user_id: List[str] = None,
|
|
sender_user_id: str = None,
|
|
text_content: str = None,
|
|
):
|
|
self.extension = extension
|
|
self.link = link
|
|
# This parameter is required.
|
|
self.message_id = message_id
|
|
# This parameter is required.
|
|
self.receiver_user_id = receiver_user_id
|
|
self.sender_user_id = sender_user_id
|
|
# This parameter is required.
|
|
self.text_content = text_content
|
|
|
|
def validate(self):
|
|
if self.link:
|
|
self.link.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.extension is not None:
|
|
result['extension'] = self.extension
|
|
if self.link is not None:
|
|
result['link'] = self.link.to_map()
|
|
if self.message_id is not None:
|
|
result['messageId'] = self.message_id
|
|
if self.receiver_user_id is not None:
|
|
result['receiverUserId'] = self.receiver_user_id
|
|
if self.sender_user_id is not None:
|
|
result['senderUserId'] = self.sender_user_id
|
|
if self.text_content is not None:
|
|
result['textContent'] = self.text_content
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('extension') is not None:
|
|
self.extension = m.get('extension')
|
|
if m.get('link') is not None:
|
|
temp_model = SendDingTipRequestLink()
|
|
self.link = temp_model.from_map(m['link'])
|
|
if m.get('messageId') is not None:
|
|
self.message_id = m.get('messageId')
|
|
if m.get('receiverUserId') is not None:
|
|
self.receiver_user_id = m.get('receiverUserId')
|
|
if m.get('senderUserId') is not None:
|
|
self.sender_user_id = m.get('senderUserId')
|
|
if m.get('textContent') is not None:
|
|
self.text_content = m.get('textContent')
|
|
return self
|
|
|
|
|
|
class SendDingTipResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
success: bool = None,
|
|
):
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.success is not None:
|
|
result['success'] = self.success
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class SendDingTipResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: SendDingTipResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = SendDingTipResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class SendMessageTipHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class SendMessageTipRequestDefaultView(TeaModel):
|
|
def __init__(
|
|
self,
|
|
action_name: str = None,
|
|
action_url: str = None,
|
|
auth_code: str = None,
|
|
auth_media_id: str = None,
|
|
card_title: str = None,
|
|
card_title_color: str = None,
|
|
desc: str = None,
|
|
media_id: str = None,
|
|
need_show_update_tail: str = None,
|
|
summary: str = None,
|
|
title: str = None,
|
|
):
|
|
self.action_name = action_name
|
|
self.action_url = action_url
|
|
self.auth_code = auth_code
|
|
self.auth_media_id = auth_media_id
|
|
self.card_title = card_title
|
|
self.card_title_color = card_title_color
|
|
self.desc = desc
|
|
self.media_id = media_id
|
|
self.need_show_update_tail = need_show_update_tail
|
|
self.summary = summary
|
|
self.title = title
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.action_name is not None:
|
|
result['actionName'] = self.action_name
|
|
if self.action_url is not None:
|
|
result['actionUrl'] = self.action_url
|
|
if self.auth_code is not None:
|
|
result['authCode'] = self.auth_code
|
|
if self.auth_media_id is not None:
|
|
result['authMediaId'] = self.auth_media_id
|
|
if self.card_title is not None:
|
|
result['cardTitle'] = self.card_title
|
|
if self.card_title_color is not None:
|
|
result['cardTitleColor'] = self.card_title_color
|
|
if self.desc is not None:
|
|
result['desc'] = self.desc
|
|
if self.media_id is not None:
|
|
result['mediaId'] = self.media_id
|
|
if self.need_show_update_tail is not None:
|
|
result['needShowUpdateTail'] = self.need_show_update_tail
|
|
if self.summary is not None:
|
|
result['summary'] = self.summary
|
|
if self.title is not None:
|
|
result['title'] = self.title
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('actionName') is not None:
|
|
self.action_name = m.get('actionName')
|
|
if m.get('actionUrl') is not None:
|
|
self.action_url = m.get('actionUrl')
|
|
if m.get('authCode') is not None:
|
|
self.auth_code = m.get('authCode')
|
|
if m.get('authMediaId') is not None:
|
|
self.auth_media_id = m.get('authMediaId')
|
|
if m.get('cardTitle') is not None:
|
|
self.card_title = m.get('cardTitle')
|
|
if m.get('cardTitleColor') is not None:
|
|
self.card_title_color = m.get('cardTitleColor')
|
|
if m.get('desc') is not None:
|
|
self.desc = m.get('desc')
|
|
if m.get('mediaId') is not None:
|
|
self.media_id = m.get('mediaId')
|
|
if m.get('needShowUpdateTail') is not None:
|
|
self.need_show_update_tail = m.get('needShowUpdateTail')
|
|
if m.get('summary') is not None:
|
|
self.summary = m.get('summary')
|
|
if m.get('title') is not None:
|
|
self.title = m.get('title')
|
|
return self
|
|
|
|
|
|
class SendMessageTipRequestPublicField(TeaModel):
|
|
def __init__(
|
|
self,
|
|
detail_url: str = None,
|
|
duration_desc: str = None,
|
|
extension: Dict[str, str] = None,
|
|
is_expired: bool = None,
|
|
read_action_url: str = None,
|
|
read_progress_desc: str = None,
|
|
):
|
|
self.detail_url = detail_url
|
|
self.duration_desc = duration_desc
|
|
self.extension = extension
|
|
self.is_expired = is_expired
|
|
self.read_action_url = read_action_url
|
|
self.read_progress_desc = read_progress_desc
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.detail_url is not None:
|
|
result['detailUrl'] = self.detail_url
|
|
if self.duration_desc is not None:
|
|
result['durationDesc'] = self.duration_desc
|
|
if self.extension is not None:
|
|
result['extension'] = self.extension
|
|
if self.is_expired is not None:
|
|
result['isExpired'] = self.is_expired
|
|
if self.read_action_url is not None:
|
|
result['readActionUrl'] = self.read_action_url
|
|
if self.read_progress_desc is not None:
|
|
result['readProgressDesc'] = self.read_progress_desc
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('detailUrl') is not None:
|
|
self.detail_url = m.get('detailUrl')
|
|
if m.get('durationDesc') is not None:
|
|
self.duration_desc = m.get('durationDesc')
|
|
if m.get('extension') is not None:
|
|
self.extension = m.get('extension')
|
|
if m.get('isExpired') is not None:
|
|
self.is_expired = m.get('isExpired')
|
|
if m.get('readActionUrl') is not None:
|
|
self.read_action_url = m.get('readActionUrl')
|
|
if m.get('readProgressDesc') is not None:
|
|
self.read_progress_desc = m.get('readProgressDesc')
|
|
return self
|
|
|
|
|
|
class SendMessageTipRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
default_view: SendMessageTipRequestDefaultView = None,
|
|
message_id: str = None,
|
|
open_conversation_id: str = None,
|
|
private_field_map: Dict[str, PrivateFieldMapValue] = None,
|
|
public_field: SendMessageTipRequestPublicField = None,
|
|
receiver_user_id: List[str] = None,
|
|
sender_user_id: str = None,
|
|
):
|
|
self.default_view = default_view
|
|
# This parameter is required.
|
|
self.message_id = message_id
|
|
# This parameter is required.
|
|
self.open_conversation_id = open_conversation_id
|
|
self.private_field_map = private_field_map
|
|
self.public_field = public_field
|
|
# This parameter is required.
|
|
self.receiver_user_id = receiver_user_id
|
|
self.sender_user_id = sender_user_id
|
|
|
|
def validate(self):
|
|
if self.default_view:
|
|
self.default_view.validate()
|
|
if self.private_field_map:
|
|
for v in self.private_field_map.values():
|
|
if v:
|
|
v.validate()
|
|
if self.public_field:
|
|
self.public_field.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.default_view is not None:
|
|
result['defaultView'] = self.default_view.to_map()
|
|
if self.message_id is not None:
|
|
result['messageId'] = self.message_id
|
|
if self.open_conversation_id is not None:
|
|
result['openConversationId'] = self.open_conversation_id
|
|
result['privateFieldMap'] = {}
|
|
if self.private_field_map is not None:
|
|
for k, v in self.private_field_map.items():
|
|
result['privateFieldMap'][k] = v.to_map()
|
|
if self.public_field is not None:
|
|
result['publicField'] = self.public_field.to_map()
|
|
if self.receiver_user_id is not None:
|
|
result['receiverUserId'] = self.receiver_user_id
|
|
if self.sender_user_id is not None:
|
|
result['senderUserId'] = self.sender_user_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('defaultView') is not None:
|
|
temp_model = SendMessageTipRequestDefaultView()
|
|
self.default_view = temp_model.from_map(m['defaultView'])
|
|
if m.get('messageId') is not None:
|
|
self.message_id = m.get('messageId')
|
|
if m.get('openConversationId') is not None:
|
|
self.open_conversation_id = m.get('openConversationId')
|
|
self.private_field_map = {}
|
|
if m.get('privateFieldMap') is not None:
|
|
for k, v in m.get('privateFieldMap').items():
|
|
temp_model = PrivateFieldMapValue()
|
|
self.private_field_map[k] = temp_model.from_map(v)
|
|
if m.get('publicField') is not None:
|
|
temp_model = SendMessageTipRequestPublicField()
|
|
self.public_field = temp_model.from_map(m['publicField'])
|
|
if m.get('receiverUserId') is not None:
|
|
self.receiver_user_id = m.get('receiverUserId')
|
|
if m.get('senderUserId') is not None:
|
|
self.sender_user_id = m.get('senderUserId')
|
|
return self
|
|
|
|
|
|
class SendMessageTipResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
biz_id: str = None,
|
|
card_instance_id: str = None,
|
|
):
|
|
self.biz_id = biz_id
|
|
self.card_instance_id = card_instance_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.biz_id is not None:
|
|
result['bizId'] = self.biz_id
|
|
if self.card_instance_id is not None:
|
|
result['cardInstanceId'] = self.card_instance_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('bizId') is not None:
|
|
self.biz_id = m.get('bizId')
|
|
if m.get('cardInstanceId') is not None:
|
|
self.card_instance_id = m.get('cardInstanceId')
|
|
return self
|
|
|
|
|
|
class SendMessageTipResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: SendMessageTipResponseBodyResult = None,
|
|
success: bool = None,
|
|
):
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
if self.result:
|
|
self.result.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.result is not None:
|
|
result['result'] = self.result.to_map()
|
|
if self.success is not None:
|
|
result['success'] = self.success
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('result') is not None:
|
|
temp_model = SendMessageTipResponseBodyResult()
|
|
self.result = temp_model.from_map(m['result'])
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class SendMessageTipResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: SendMessageTipResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = SendMessageTipResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|