5649 lines
179 KiB
Python
5649 lines
179 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 CreateBookingBlacklistHeaders(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 CreateBookingBlacklistRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
blacklist_union_id: str = None,
|
|
end_time: int = None,
|
|
memo: str = None,
|
|
start_time: int = None,
|
|
union_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.blacklist_union_id = blacklist_union_id
|
|
self.end_time = end_time
|
|
self.memo = memo
|
|
# This parameter is required.
|
|
self.start_time = start_time
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.blacklist_union_id is not None:
|
|
result['blacklistUnionId'] = self.blacklist_union_id
|
|
if self.end_time is not None:
|
|
result['endTime'] = self.end_time
|
|
if self.memo is not None:
|
|
result['memo'] = self.memo
|
|
if self.start_time is not None:
|
|
result['startTime'] = self.start_time
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('blacklistUnionId') is not None:
|
|
self.blacklist_union_id = m.get('blacklistUnionId')
|
|
if m.get('endTime') is not None:
|
|
self.end_time = m.get('endTime')
|
|
if m.get('memo') is not None:
|
|
self.memo = m.get('memo')
|
|
if m.get('startTime') is not None:
|
|
self.start_time = m.get('startTime')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class CreateBookingBlacklistResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: bool = 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 CreateBookingBlacklistResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: CreateBookingBlacklistResponseBody = 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 = CreateBookingBlacklistResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class CreateDeviceCustomTemplateHeaders(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 CreateDeviceCustomTemplateRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
bg_img_list: List[str] = None,
|
|
bg_type: int = None,
|
|
bg_url: str = None,
|
|
custom_doc: str = None,
|
|
desensitize_user_name: bool = None,
|
|
device_union_ids: List[str] = None,
|
|
group_ids: List[int] = None,
|
|
hide_server_code_when_projecting: bool = None,
|
|
instruction: bool = None,
|
|
is_pic_top: int = None,
|
|
logo: str = None,
|
|
org_name: str = None,
|
|
picture_play_interval: int = None,
|
|
room_ids: List[str] = None,
|
|
show_calendar_card: bool = None,
|
|
show_calendar_title: bool = None,
|
|
show_function_card: bool = None,
|
|
template_name: str = None,
|
|
):
|
|
self.bg_img_list = bg_img_list
|
|
self.bg_type = bg_type
|
|
self.bg_url = bg_url
|
|
self.custom_doc = custom_doc
|
|
self.desensitize_user_name = desensitize_user_name
|
|
self.device_union_ids = device_union_ids
|
|
self.group_ids = group_ids
|
|
self.hide_server_code_when_projecting = hide_server_code_when_projecting
|
|
self.instruction = instruction
|
|
self.is_pic_top = is_pic_top
|
|
self.logo = logo
|
|
self.org_name = org_name
|
|
self.picture_play_interval = picture_play_interval
|
|
self.room_ids = room_ids
|
|
self.show_calendar_card = show_calendar_card
|
|
self.show_calendar_title = show_calendar_title
|
|
self.show_function_card = show_function_card
|
|
# This parameter is required.
|
|
self.template_name = template_name
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.bg_img_list is not None:
|
|
result['bgImgList'] = self.bg_img_list
|
|
if self.bg_type is not None:
|
|
result['bgType'] = self.bg_type
|
|
if self.bg_url is not None:
|
|
result['bgUrl'] = self.bg_url
|
|
if self.custom_doc is not None:
|
|
result['customDoc'] = self.custom_doc
|
|
if self.desensitize_user_name is not None:
|
|
result['desensitizeUserName'] = self.desensitize_user_name
|
|
if self.device_union_ids is not None:
|
|
result['deviceUnionIds'] = self.device_union_ids
|
|
if self.group_ids is not None:
|
|
result['groupIds'] = self.group_ids
|
|
if self.hide_server_code_when_projecting is not None:
|
|
result['hideServerCodeWhenProjecting'] = self.hide_server_code_when_projecting
|
|
if self.instruction is not None:
|
|
result['instruction'] = self.instruction
|
|
if self.is_pic_top is not None:
|
|
result['isPicTop'] = self.is_pic_top
|
|
if self.logo is not None:
|
|
result['logo'] = self.logo
|
|
if self.org_name is not None:
|
|
result['orgName'] = self.org_name
|
|
if self.picture_play_interval is not None:
|
|
result['picturePlayInterval'] = self.picture_play_interval
|
|
if self.room_ids is not None:
|
|
result['roomIds'] = self.room_ids
|
|
if self.show_calendar_card is not None:
|
|
result['showCalendarCard'] = self.show_calendar_card
|
|
if self.show_calendar_title is not None:
|
|
result['showCalendarTitle'] = self.show_calendar_title
|
|
if self.show_function_card is not None:
|
|
result['showFunctionCard'] = self.show_function_card
|
|
if self.template_name is not None:
|
|
result['templateName'] = self.template_name
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('bgImgList') is not None:
|
|
self.bg_img_list = m.get('bgImgList')
|
|
if m.get('bgType') is not None:
|
|
self.bg_type = m.get('bgType')
|
|
if m.get('bgUrl') is not None:
|
|
self.bg_url = m.get('bgUrl')
|
|
if m.get('customDoc') is not None:
|
|
self.custom_doc = m.get('customDoc')
|
|
if m.get('desensitizeUserName') is not None:
|
|
self.desensitize_user_name = m.get('desensitizeUserName')
|
|
if m.get('deviceUnionIds') is not None:
|
|
self.device_union_ids = m.get('deviceUnionIds')
|
|
if m.get('groupIds') is not None:
|
|
self.group_ids = m.get('groupIds')
|
|
if m.get('hideServerCodeWhenProjecting') is not None:
|
|
self.hide_server_code_when_projecting = m.get('hideServerCodeWhenProjecting')
|
|
if m.get('instruction') is not None:
|
|
self.instruction = m.get('instruction')
|
|
if m.get('isPicTop') is not None:
|
|
self.is_pic_top = m.get('isPicTop')
|
|
if m.get('logo') is not None:
|
|
self.logo = m.get('logo')
|
|
if m.get('orgName') is not None:
|
|
self.org_name = m.get('orgName')
|
|
if m.get('picturePlayInterval') is not None:
|
|
self.picture_play_interval = m.get('picturePlayInterval')
|
|
if m.get('roomIds') is not None:
|
|
self.room_ids = m.get('roomIds')
|
|
if m.get('showCalendarCard') is not None:
|
|
self.show_calendar_card = m.get('showCalendarCard')
|
|
if m.get('showCalendarTitle') is not None:
|
|
self.show_calendar_title = m.get('showCalendarTitle')
|
|
if m.get('showFunctionCard') is not None:
|
|
self.show_function_card = m.get('showFunctionCard')
|
|
if m.get('templateName') is not None:
|
|
self.template_name = m.get('templateName')
|
|
return self
|
|
|
|
|
|
class CreateDeviceCustomTemplateResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
template_id: int = None,
|
|
):
|
|
self.template_id = template_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.template_id is not None:
|
|
result['templateId'] = self.template_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('templateId') is not None:
|
|
self.template_id = m.get('templateId')
|
|
return self
|
|
|
|
|
|
class CreateDeviceCustomTemplateResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: CreateDeviceCustomTemplateResponseBody = 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 = CreateDeviceCustomTemplateResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class CreateMeetingRoomHeaders(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 CreateMeetingRoomRequestReservationAuthorityAuthorizedMembers(TeaModel):
|
|
def __init__(
|
|
self,
|
|
member_id: str = None,
|
|
member_name: str = None,
|
|
member_type: str = None,
|
|
):
|
|
self.member_id = member_id
|
|
self.member_name = member_name
|
|
self.member_type = member_type
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.member_id is not None:
|
|
result['memberId'] = self.member_id
|
|
if self.member_name is not None:
|
|
result['memberName'] = self.member_name
|
|
if self.member_type is not None:
|
|
result['memberType'] = self.member_type
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('memberId') is not None:
|
|
self.member_id = m.get('memberId')
|
|
if m.get('memberName') is not None:
|
|
self.member_name = m.get('memberName')
|
|
if m.get('memberType') is not None:
|
|
self.member_type = m.get('memberType')
|
|
return self
|
|
|
|
|
|
class CreateMeetingRoomRequestReservationAuthority(TeaModel):
|
|
def __init__(
|
|
self,
|
|
authorized_members: List[CreateMeetingRoomRequestReservationAuthorityAuthorizedMembers] = None,
|
|
):
|
|
self.authorized_members = authorized_members
|
|
|
|
def validate(self):
|
|
if self.authorized_members:
|
|
for k in self.authorized_members:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['authorizedMembers'] = []
|
|
if self.authorized_members is not None:
|
|
for k in self.authorized_members:
|
|
result['authorizedMembers'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.authorized_members = []
|
|
if m.get('authorizedMembers') is not None:
|
|
for k in m.get('authorizedMembers'):
|
|
temp_model = CreateMeetingRoomRequestReservationAuthorityAuthorizedMembers()
|
|
self.authorized_members.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class CreateMeetingRoomRequestRoomLocation(TeaModel):
|
|
def __init__(
|
|
self,
|
|
desc: str = None,
|
|
title: str = None,
|
|
):
|
|
self.desc = desc
|
|
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.desc is not None:
|
|
result['desc'] = self.desc
|
|
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('desc') is not None:
|
|
self.desc = m.get('desc')
|
|
if m.get('title') is not None:
|
|
self.title = m.get('title')
|
|
return self
|
|
|
|
|
|
class CreateMeetingRoomRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
enable_cycle_reservation: bool = None,
|
|
group_id: int = None,
|
|
isv_room_id: str = None,
|
|
open_reservation: bool = None,
|
|
reservation_authority: CreateMeetingRoomRequestReservationAuthority = None,
|
|
room_capacity: int = None,
|
|
room_label_ids: List[int] = None,
|
|
room_location: CreateMeetingRoomRequestRoomLocation = None,
|
|
room_name: str = None,
|
|
room_picture: str = None,
|
|
room_status: int = None,
|
|
union_id: str = None,
|
|
):
|
|
self.enable_cycle_reservation = enable_cycle_reservation
|
|
self.group_id = group_id
|
|
# This parameter is required.
|
|
self.isv_room_id = isv_room_id
|
|
self.open_reservation = open_reservation
|
|
self.reservation_authority = reservation_authority
|
|
self.room_capacity = room_capacity
|
|
self.room_label_ids = room_label_ids
|
|
self.room_location = room_location
|
|
# This parameter is required.
|
|
self.room_name = room_name
|
|
self.room_picture = room_picture
|
|
# This parameter is required.
|
|
self.room_status = room_status
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
if self.reservation_authority:
|
|
self.reservation_authority.validate()
|
|
if self.room_location:
|
|
self.room_location.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.enable_cycle_reservation is not None:
|
|
result['enableCycleReservation'] = self.enable_cycle_reservation
|
|
if self.group_id is not None:
|
|
result['groupId'] = self.group_id
|
|
if self.isv_room_id is not None:
|
|
result['isvRoomId'] = self.isv_room_id
|
|
if self.open_reservation is not None:
|
|
result['openReservation'] = self.open_reservation
|
|
if self.reservation_authority is not None:
|
|
result['reservationAuthority'] = self.reservation_authority.to_map()
|
|
if self.room_capacity is not None:
|
|
result['roomCapacity'] = self.room_capacity
|
|
if self.room_label_ids is not None:
|
|
result['roomLabelIds'] = self.room_label_ids
|
|
if self.room_location is not None:
|
|
result['roomLocation'] = self.room_location.to_map()
|
|
if self.room_name is not None:
|
|
result['roomName'] = self.room_name
|
|
if self.room_picture is not None:
|
|
result['roomPicture'] = self.room_picture
|
|
if self.room_status is not None:
|
|
result['roomStatus'] = self.room_status
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('enableCycleReservation') is not None:
|
|
self.enable_cycle_reservation = m.get('enableCycleReservation')
|
|
if m.get('groupId') is not None:
|
|
self.group_id = m.get('groupId')
|
|
if m.get('isvRoomId') is not None:
|
|
self.isv_room_id = m.get('isvRoomId')
|
|
if m.get('openReservation') is not None:
|
|
self.open_reservation = m.get('openReservation')
|
|
if m.get('reservationAuthority') is not None:
|
|
temp_model = CreateMeetingRoomRequestReservationAuthority()
|
|
self.reservation_authority = temp_model.from_map(m['reservationAuthority'])
|
|
if m.get('roomCapacity') is not None:
|
|
self.room_capacity = m.get('roomCapacity')
|
|
if m.get('roomLabelIds') is not None:
|
|
self.room_label_ids = m.get('roomLabelIds')
|
|
if m.get('roomLocation') is not None:
|
|
temp_model = CreateMeetingRoomRequestRoomLocation()
|
|
self.room_location = temp_model.from_map(m['roomLocation'])
|
|
if m.get('roomName') is not None:
|
|
self.room_name = m.get('roomName')
|
|
if m.get('roomPicture') is not None:
|
|
self.room_picture = m.get('roomPicture')
|
|
if m.get('roomStatus') is not None:
|
|
self.room_status = m.get('roomStatus')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class CreateMeetingRoomResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: 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 CreateMeetingRoomResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: CreateMeetingRoomResponseBody = 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 = CreateMeetingRoomResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class CreateMeetingRoomControlPanelHeaders(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 CreateMeetingRoomControlPanelRequestExtra(TeaModel):
|
|
def __init__(
|
|
self,
|
|
param: Dict[str, str] = None,
|
|
):
|
|
self.param = param
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.param is not None:
|
|
result['param'] = self.param
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('param') is not None:
|
|
self.param = m.get('param')
|
|
return self
|
|
|
|
|
|
class CreateMeetingRoomControlPanelRequestRoomConfig(TeaModel):
|
|
def __init__(
|
|
self,
|
|
en_name: str = None,
|
|
icon: str = None,
|
|
name: str = None,
|
|
show_time: int = None,
|
|
sort: int = None,
|
|
url: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.en_name = en_name
|
|
# This parameter is required.
|
|
self.icon = icon
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.show_time = show_time
|
|
# This parameter is required.
|
|
self.sort = sort
|
|
# This parameter is required.
|
|
self.url = url
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.en_name is not None:
|
|
result['enName'] = self.en_name
|
|
if self.icon is not None:
|
|
result['icon'] = self.icon
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.show_time is not None:
|
|
result['showTime'] = self.show_time
|
|
if self.sort is not None:
|
|
result['sort'] = self.sort
|
|
if self.url is not None:
|
|
result['url'] = self.url
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('enName') is not None:
|
|
self.en_name = m.get('enName')
|
|
if m.get('icon') is not None:
|
|
self.icon = m.get('icon')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('showTime') is not None:
|
|
self.show_time = m.get('showTime')
|
|
if m.get('sort') is not None:
|
|
self.sort = m.get('sort')
|
|
if m.get('url') is not None:
|
|
self.url = m.get('url')
|
|
return self
|
|
|
|
|
|
class CreateMeetingRoomControlPanelRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
extra: CreateMeetingRoomControlPanelRequestExtra = None,
|
|
room_config: List[CreateMeetingRoomControlPanelRequestRoomConfig] = None,
|
|
room_id: str = None,
|
|
status: int = None,
|
|
union_id: str = None,
|
|
):
|
|
self.extra = extra
|
|
# This parameter is required.
|
|
self.room_config = room_config
|
|
# This parameter is required.
|
|
self.room_id = room_id
|
|
self.status = status
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
if self.extra:
|
|
self.extra.validate()
|
|
if self.room_config:
|
|
for k in self.room_config:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.extra is not None:
|
|
result['extra'] = self.extra.to_map()
|
|
result['roomConfig'] = []
|
|
if self.room_config is not None:
|
|
for k in self.room_config:
|
|
result['roomConfig'].append(k.to_map() if k else None)
|
|
if self.room_id is not None:
|
|
result['roomId'] = self.room_id
|
|
if self.status is not None:
|
|
result['status'] = self.status
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('extra') is not None:
|
|
temp_model = CreateMeetingRoomControlPanelRequestExtra()
|
|
self.extra = temp_model.from_map(m['extra'])
|
|
self.room_config = []
|
|
if m.get('roomConfig') is not None:
|
|
for k in m.get('roomConfig'):
|
|
temp_model = CreateMeetingRoomControlPanelRequestRoomConfig()
|
|
self.room_config.append(temp_model.from_map(k))
|
|
if m.get('roomId') is not None:
|
|
self.room_id = m.get('roomId')
|
|
if m.get('status') is not None:
|
|
self.status = m.get('status')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class CreateMeetingRoomControlPanelResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: 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 CreateMeetingRoomControlPanelResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: CreateMeetingRoomControlPanelResponseBody = 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 = CreateMeetingRoomControlPanelResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class CreateMeetingRoomGroupHeaders(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 CreateMeetingRoomGroupRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
group_name: str = None,
|
|
parent_group_id: int = None,
|
|
union_id: str = None,
|
|
):
|
|
self.group_name = group_name
|
|
# This parameter is required.
|
|
self.parent_group_id = parent_group_id
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.group_name is not None:
|
|
result['groupName'] = self.group_name
|
|
if self.parent_group_id is not None:
|
|
result['parentGroupId'] = self.parent_group_id
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('groupName') is not None:
|
|
self.group_name = m.get('groupName')
|
|
if m.get('parentGroupId') is not None:
|
|
self.parent_group_id = m.get('parentGroupId')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class CreateMeetingRoomGroupResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: int = 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 CreateMeetingRoomGroupResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: CreateMeetingRoomGroupResponseBody = 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 = CreateMeetingRoomGroupResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class DeleteBookingBlacklistHeaders(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 DeleteBookingBlacklistRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
blacklist_union_ids: List[str] = None,
|
|
union_id: str = None,
|
|
):
|
|
self.blacklist_union_ids = blacklist_union_ids
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.blacklist_union_ids is not None:
|
|
result['blacklistUnionIds'] = self.blacklist_union_ids
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('blacklistUnionIds') is not None:
|
|
self.blacklist_union_ids = m.get('blacklistUnionIds')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class DeleteBookingBlacklistResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: bool = 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 DeleteBookingBlacklistResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: DeleteBookingBlacklistResponseBody = 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 = DeleteBookingBlacklistResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class DeleteDeviceCustomTemplateHeaders(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 DeleteDeviceCustomTemplateRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
template_id: int = None,
|
|
):
|
|
# This parameter is required.
|
|
self.template_id = template_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.template_id is not None:
|
|
result['templateId'] = self.template_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('templateId') is not None:
|
|
self.template_id = m.get('templateId')
|
|
return self
|
|
|
|
|
|
class DeleteDeviceCustomTemplateResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: bool = 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 DeleteDeviceCustomTemplateResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: DeleteDeviceCustomTemplateResponseBody = 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 = DeleteDeviceCustomTemplateResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class DeleteMeetingRoomHeaders(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 DeleteMeetingRoomRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
union_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class DeleteMeetingRoomResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: bool = 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 DeleteMeetingRoomResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: DeleteMeetingRoomResponseBody = 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 = DeleteMeetingRoomResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class DeleteMeetingRoomControlPanelHeaders(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 DeleteMeetingRoomControlPanelRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
room_ids: List[str] = None,
|
|
union_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.room_ids = room_ids
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.room_ids is not None:
|
|
result['roomIds'] = self.room_ids
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('roomIds') is not None:
|
|
self.room_ids = m.get('roomIds')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class DeleteMeetingRoomControlPanelResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: 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 DeleteMeetingRoomControlPanelResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: DeleteMeetingRoomControlPanelResponseBody = 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 = DeleteMeetingRoomControlPanelResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class DeleteMeetingRoomGroupHeaders(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 DeleteMeetingRoomGroupRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
union_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class DeleteMeetingRoomGroupResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: bool = 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 DeleteMeetingRoomGroupResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: DeleteMeetingRoomGroupResponseBody = 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 = DeleteMeetingRoomGroupResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryDeviceCustomTemplateHeaders(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 QueryDeviceCustomTemplateResponseBodyResultDeviceCustomTemplate(TeaModel):
|
|
def __init__(
|
|
self,
|
|
bg_image_list: List[str] = None,
|
|
bg_type: int = None,
|
|
bg_url: str = None,
|
|
conf_sub_type: int = None,
|
|
conf_type: int = None,
|
|
corp_id: str = None,
|
|
custom_doc: str = None,
|
|
desensitize_user_name: bool = None,
|
|
hide_server_code_when_projecting: bool = None,
|
|
instruction: bool = None,
|
|
is_pic_top: int = None,
|
|
logo: str = None,
|
|
org_name: str = None,
|
|
picture_play_interval: int = None,
|
|
show_calendar_card: bool = None,
|
|
show_calendar_title: bool = None,
|
|
show_function_card: bool = None,
|
|
template_id: int = None,
|
|
template_name: str = None,
|
|
):
|
|
self.bg_image_list = bg_image_list
|
|
self.bg_type = bg_type
|
|
self.bg_url = bg_url
|
|
self.conf_sub_type = conf_sub_type
|
|
self.conf_type = conf_type
|
|
self.corp_id = corp_id
|
|
self.custom_doc = custom_doc
|
|
self.desensitize_user_name = desensitize_user_name
|
|
self.hide_server_code_when_projecting = hide_server_code_when_projecting
|
|
self.instruction = instruction
|
|
self.is_pic_top = is_pic_top
|
|
self.logo = logo
|
|
self.org_name = org_name
|
|
self.picture_play_interval = picture_play_interval
|
|
self.show_calendar_card = show_calendar_card
|
|
self.show_calendar_title = show_calendar_title
|
|
self.show_function_card = show_function_card
|
|
self.template_id = template_id
|
|
self.template_name = template_name
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.bg_image_list is not None:
|
|
result['bgImageList'] = self.bg_image_list
|
|
if self.bg_type is not None:
|
|
result['bgType'] = self.bg_type
|
|
if self.bg_url is not None:
|
|
result['bgUrl'] = self.bg_url
|
|
if self.conf_sub_type is not None:
|
|
result['confSubType'] = self.conf_sub_type
|
|
if self.conf_type is not None:
|
|
result['confType'] = self.conf_type
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
if self.custom_doc is not None:
|
|
result['customDoc'] = self.custom_doc
|
|
if self.desensitize_user_name is not None:
|
|
result['desensitizeUserName'] = self.desensitize_user_name
|
|
if self.hide_server_code_when_projecting is not None:
|
|
result['hideServerCodeWhenProjecting'] = self.hide_server_code_when_projecting
|
|
if self.instruction is not None:
|
|
result['instruction'] = self.instruction
|
|
if self.is_pic_top is not None:
|
|
result['isPicTop'] = self.is_pic_top
|
|
if self.logo is not None:
|
|
result['logo'] = self.logo
|
|
if self.org_name is not None:
|
|
result['orgName'] = self.org_name
|
|
if self.picture_play_interval is not None:
|
|
result['picturePlayInterval'] = self.picture_play_interval
|
|
if self.show_calendar_card is not None:
|
|
result['showCalendarCard'] = self.show_calendar_card
|
|
if self.show_calendar_title is not None:
|
|
result['showCalendarTitle'] = self.show_calendar_title
|
|
if self.show_function_card is not None:
|
|
result['showFunctionCard'] = self.show_function_card
|
|
if self.template_id is not None:
|
|
result['templateId'] = self.template_id
|
|
if self.template_name is not None:
|
|
result['templateName'] = self.template_name
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('bgImageList') is not None:
|
|
self.bg_image_list = m.get('bgImageList')
|
|
if m.get('bgType') is not None:
|
|
self.bg_type = m.get('bgType')
|
|
if m.get('bgUrl') is not None:
|
|
self.bg_url = m.get('bgUrl')
|
|
if m.get('confSubType') is not None:
|
|
self.conf_sub_type = m.get('confSubType')
|
|
if m.get('confType') is not None:
|
|
self.conf_type = m.get('confType')
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
if m.get('customDoc') is not None:
|
|
self.custom_doc = m.get('customDoc')
|
|
if m.get('desensitizeUserName') is not None:
|
|
self.desensitize_user_name = m.get('desensitizeUserName')
|
|
if m.get('hideServerCodeWhenProjecting') is not None:
|
|
self.hide_server_code_when_projecting = m.get('hideServerCodeWhenProjecting')
|
|
if m.get('instruction') is not None:
|
|
self.instruction = m.get('instruction')
|
|
if m.get('isPicTop') is not None:
|
|
self.is_pic_top = m.get('isPicTop')
|
|
if m.get('logo') is not None:
|
|
self.logo = m.get('logo')
|
|
if m.get('orgName') is not None:
|
|
self.org_name = m.get('orgName')
|
|
if m.get('picturePlayInterval') is not None:
|
|
self.picture_play_interval = m.get('picturePlayInterval')
|
|
if m.get('showCalendarCard') is not None:
|
|
self.show_calendar_card = m.get('showCalendarCard')
|
|
if m.get('showCalendarTitle') is not None:
|
|
self.show_calendar_title = m.get('showCalendarTitle')
|
|
if m.get('showFunctionCard') is not None:
|
|
self.show_function_card = m.get('showFunctionCard')
|
|
if m.get('templateId') is not None:
|
|
self.template_id = m.get('templateId')
|
|
if m.get('templateName') is not None:
|
|
self.template_name = m.get('templateName')
|
|
return self
|
|
|
|
|
|
class QueryDeviceCustomTemplateResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
device_custom_template: QueryDeviceCustomTemplateResponseBodyResultDeviceCustomTemplate = None,
|
|
device_union_ids: List[str] = None,
|
|
group_ids: List[int] = None,
|
|
room_ids: List[str] = None,
|
|
):
|
|
self.device_custom_template = device_custom_template
|
|
self.device_union_ids = device_union_ids
|
|
self.group_ids = group_ids
|
|
self.room_ids = room_ids
|
|
|
|
def validate(self):
|
|
if self.device_custom_template:
|
|
self.device_custom_template.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.device_custom_template is not None:
|
|
result['deviceCustomTemplate'] = self.device_custom_template.to_map()
|
|
if self.device_union_ids is not None:
|
|
result['deviceUnionIds'] = self.device_union_ids
|
|
if self.group_ids is not None:
|
|
result['groupIds'] = self.group_ids
|
|
if self.room_ids is not None:
|
|
result['roomIds'] = self.room_ids
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('deviceCustomTemplate') is not None:
|
|
temp_model = QueryDeviceCustomTemplateResponseBodyResultDeviceCustomTemplate()
|
|
self.device_custom_template = temp_model.from_map(m['deviceCustomTemplate'])
|
|
if m.get('deviceUnionIds') is not None:
|
|
self.device_union_ids = m.get('deviceUnionIds')
|
|
if m.get('groupIds') is not None:
|
|
self.group_ids = m.get('groupIds')
|
|
if m.get('roomIds') is not None:
|
|
self.room_ids = m.get('roomIds')
|
|
return self
|
|
|
|
|
|
class QueryDeviceCustomTemplateResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: QueryDeviceCustomTemplateResponseBodyResult = None,
|
|
):
|
|
self.result = result
|
|
|
|
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()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('result') is not None:
|
|
temp_model = QueryDeviceCustomTemplateResponseBodyResult()
|
|
self.result = temp_model.from_map(m['result'])
|
|
return self
|
|
|
|
|
|
class QueryDeviceCustomTemplateResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryDeviceCustomTemplateResponseBody = 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 = QueryDeviceCustomTemplateResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryDeviceCustomTemplateListHeaders(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 QueryDeviceCustomTemplateListResponseBodyResultDeviceCustomTemplates(TeaModel):
|
|
def __init__(
|
|
self,
|
|
bg_image_list: List[str] = None,
|
|
bg_type: int = None,
|
|
bg_url: str = None,
|
|
conf_sub_type: int = None,
|
|
conf_type: int = None,
|
|
corp_id: str = None,
|
|
custom_doc: str = None,
|
|
desensitize_user_name: bool = None,
|
|
hide_server_code_when_projecting: bool = None,
|
|
instruction: bool = None,
|
|
is_pic_top: int = None,
|
|
logo: str = None,
|
|
org_name: str = None,
|
|
picture_play_interval: int = None,
|
|
show_calendar_card: bool = None,
|
|
show_calendar_title: bool = None,
|
|
show_function_card: bool = None,
|
|
template_id: int = None,
|
|
template_name: str = None,
|
|
):
|
|
self.bg_image_list = bg_image_list
|
|
self.bg_type = bg_type
|
|
self.bg_url = bg_url
|
|
self.conf_sub_type = conf_sub_type
|
|
self.conf_type = conf_type
|
|
self.corp_id = corp_id
|
|
self.custom_doc = custom_doc
|
|
self.desensitize_user_name = desensitize_user_name
|
|
self.hide_server_code_when_projecting = hide_server_code_when_projecting
|
|
self.instruction = instruction
|
|
self.is_pic_top = is_pic_top
|
|
self.logo = logo
|
|
self.org_name = org_name
|
|
self.picture_play_interval = picture_play_interval
|
|
self.show_calendar_card = show_calendar_card
|
|
self.show_calendar_title = show_calendar_title
|
|
self.show_function_card = show_function_card
|
|
self.template_id = template_id
|
|
self.template_name = template_name
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.bg_image_list is not None:
|
|
result['bgImageList'] = self.bg_image_list
|
|
if self.bg_type is not None:
|
|
result['bgType'] = self.bg_type
|
|
if self.bg_url is not None:
|
|
result['bgUrl'] = self.bg_url
|
|
if self.conf_sub_type is not None:
|
|
result['confSubType'] = self.conf_sub_type
|
|
if self.conf_type is not None:
|
|
result['confType'] = self.conf_type
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
if self.custom_doc is not None:
|
|
result['customDoc'] = self.custom_doc
|
|
if self.desensitize_user_name is not None:
|
|
result['desensitizeUserName'] = self.desensitize_user_name
|
|
if self.hide_server_code_when_projecting is not None:
|
|
result['hideServerCodeWhenProjecting'] = self.hide_server_code_when_projecting
|
|
if self.instruction is not None:
|
|
result['instruction'] = self.instruction
|
|
if self.is_pic_top is not None:
|
|
result['isPicTop'] = self.is_pic_top
|
|
if self.logo is not None:
|
|
result['logo'] = self.logo
|
|
if self.org_name is not None:
|
|
result['orgName'] = self.org_name
|
|
if self.picture_play_interval is not None:
|
|
result['picturePlayInterval'] = self.picture_play_interval
|
|
if self.show_calendar_card is not None:
|
|
result['showCalendarCard'] = self.show_calendar_card
|
|
if self.show_calendar_title is not None:
|
|
result['showCalendarTitle'] = self.show_calendar_title
|
|
if self.show_function_card is not None:
|
|
result['showFunctionCard'] = self.show_function_card
|
|
if self.template_id is not None:
|
|
result['templateId'] = self.template_id
|
|
if self.template_name is not None:
|
|
result['templateName'] = self.template_name
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('bgImageList') is not None:
|
|
self.bg_image_list = m.get('bgImageList')
|
|
if m.get('bgType') is not None:
|
|
self.bg_type = m.get('bgType')
|
|
if m.get('bgUrl') is not None:
|
|
self.bg_url = m.get('bgUrl')
|
|
if m.get('confSubType') is not None:
|
|
self.conf_sub_type = m.get('confSubType')
|
|
if m.get('confType') is not None:
|
|
self.conf_type = m.get('confType')
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
if m.get('customDoc') is not None:
|
|
self.custom_doc = m.get('customDoc')
|
|
if m.get('desensitizeUserName') is not None:
|
|
self.desensitize_user_name = m.get('desensitizeUserName')
|
|
if m.get('hideServerCodeWhenProjecting') is not None:
|
|
self.hide_server_code_when_projecting = m.get('hideServerCodeWhenProjecting')
|
|
if m.get('instruction') is not None:
|
|
self.instruction = m.get('instruction')
|
|
if m.get('isPicTop') is not None:
|
|
self.is_pic_top = m.get('isPicTop')
|
|
if m.get('logo') is not None:
|
|
self.logo = m.get('logo')
|
|
if m.get('orgName') is not None:
|
|
self.org_name = m.get('orgName')
|
|
if m.get('picturePlayInterval') is not None:
|
|
self.picture_play_interval = m.get('picturePlayInterval')
|
|
if m.get('showCalendarCard') is not None:
|
|
self.show_calendar_card = m.get('showCalendarCard')
|
|
if m.get('showCalendarTitle') is not None:
|
|
self.show_calendar_title = m.get('showCalendarTitle')
|
|
if m.get('showFunctionCard') is not None:
|
|
self.show_function_card = m.get('showFunctionCard')
|
|
if m.get('templateId') is not None:
|
|
self.template_id = m.get('templateId')
|
|
if m.get('templateName') is not None:
|
|
self.template_name = m.get('templateName')
|
|
return self
|
|
|
|
|
|
class QueryDeviceCustomTemplateListResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
device_custom_templates: List[QueryDeviceCustomTemplateListResponseBodyResultDeviceCustomTemplates] = None,
|
|
device_template_map: Dict[str, List[str]] = None,
|
|
group_id_template_map: Dict[str, List[int]] = None,
|
|
room_id_template_map: Dict[str, List[str]] = None,
|
|
):
|
|
self.device_custom_templates = device_custom_templates
|
|
self.device_template_map = device_template_map
|
|
self.group_id_template_map = group_id_template_map
|
|
self.room_id_template_map = room_id_template_map
|
|
|
|
def validate(self):
|
|
if self.device_custom_templates:
|
|
for k in self.device_custom_templates:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['deviceCustomTemplates'] = []
|
|
if self.device_custom_templates is not None:
|
|
for k in self.device_custom_templates:
|
|
result['deviceCustomTemplates'].append(k.to_map() if k else None)
|
|
if self.device_template_map is not None:
|
|
result['deviceTemplateMap'] = self.device_template_map
|
|
if self.group_id_template_map is not None:
|
|
result['groupIdTemplateMap'] = self.group_id_template_map
|
|
if self.room_id_template_map is not None:
|
|
result['roomIdTemplateMap'] = self.room_id_template_map
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.device_custom_templates = []
|
|
if m.get('deviceCustomTemplates') is not None:
|
|
for k in m.get('deviceCustomTemplates'):
|
|
temp_model = QueryDeviceCustomTemplateListResponseBodyResultDeviceCustomTemplates()
|
|
self.device_custom_templates.append(temp_model.from_map(k))
|
|
if m.get('deviceTemplateMap') is not None:
|
|
self.device_template_map = m.get('deviceTemplateMap')
|
|
if m.get('groupIdTemplateMap') is not None:
|
|
self.group_id_template_map = m.get('groupIdTemplateMap')
|
|
if m.get('roomIdTemplateMap') is not None:
|
|
self.room_id_template_map = m.get('roomIdTemplateMap')
|
|
return self
|
|
|
|
|
|
class QueryDeviceCustomTemplateListResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: QueryDeviceCustomTemplateListResponseBodyResult = None,
|
|
):
|
|
self.result = result
|
|
|
|
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()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('result') is not None:
|
|
temp_model = QueryDeviceCustomTemplateListResponseBodyResult()
|
|
self.result = temp_model.from_map(m['result'])
|
|
return self
|
|
|
|
|
|
class QueryDeviceCustomTemplateListResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryDeviceCustomTemplateListResponseBody = 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 = QueryDeviceCustomTemplateListResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryDeviceIpByCodeHeaders(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 QueryDeviceIpByCodeRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
device_sn: str = None,
|
|
):
|
|
self.device_sn = device_sn
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.device_sn is not None:
|
|
result['deviceSn'] = self.device_sn
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('deviceSn') is not None:
|
|
self.device_sn = m.get('deviceSn')
|
|
return self
|
|
|
|
|
|
class QueryDeviceIpByCodeResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
device_ip: str = None,
|
|
):
|
|
self.device_ip = device_ip
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.device_ip is not None:
|
|
result['deviceIp'] = self.device_ip
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('deviceIp') is not None:
|
|
self.device_ip = m.get('deviceIp')
|
|
return self
|
|
|
|
|
|
class QueryDeviceIpByCodeResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: QueryDeviceIpByCodeResponseBodyResult = 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 = QueryDeviceIpByCodeResponseBodyResult()
|
|
self.result = temp_model.from_map(m['result'])
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class QueryDeviceIpByCodeResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryDeviceIpByCodeResponseBody = 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 = QueryDeviceIpByCodeResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryDevicePropertiesHeaders(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 QueryDevicePropertiesRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
property_names: List[str] = None,
|
|
device_id: str = None,
|
|
device_union_id: str = None,
|
|
operator_union_id: str = None,
|
|
):
|
|
self.property_names = property_names
|
|
self.device_id = device_id
|
|
self.device_union_id = device_union_id
|
|
# This parameter is required.
|
|
self.operator_union_id = operator_union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.property_names is not None:
|
|
result['propertyNames'] = self.property_names
|
|
if self.device_id is not None:
|
|
result['deviceId'] = self.device_id
|
|
if self.device_union_id is not None:
|
|
result['deviceUnionId'] = self.device_union_id
|
|
if self.operator_union_id is not None:
|
|
result['operatorUnionId'] = self.operator_union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('propertyNames') is not None:
|
|
self.property_names = m.get('propertyNames')
|
|
if m.get('deviceId') is not None:
|
|
self.device_id = m.get('deviceId')
|
|
if m.get('deviceUnionId') is not None:
|
|
self.device_union_id = m.get('deviceUnionId')
|
|
if m.get('operatorUnionId') is not None:
|
|
self.operator_union_id = m.get('operatorUnionId')
|
|
return self
|
|
|
|
|
|
class QueryDevicePropertiesResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
property_name: str = None,
|
|
property_value: str = None,
|
|
):
|
|
self.property_name = property_name
|
|
self.property_value = property_value
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.property_name is not None:
|
|
result['propertyName'] = self.property_name
|
|
if self.property_value is not None:
|
|
result['propertyValue'] = self.property_value
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('propertyName') is not None:
|
|
self.property_name = m.get('propertyName')
|
|
if m.get('propertyValue') is not None:
|
|
self.property_value = m.get('propertyValue')
|
|
return self
|
|
|
|
|
|
class QueryDevicePropertiesResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: List[QueryDevicePropertiesResponseBodyResult] = None,
|
|
):
|
|
self.result = result
|
|
|
|
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)
|
|
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 = QueryDevicePropertiesResponseBodyResult()
|
|
self.result.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class QueryDevicePropertiesResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryDevicePropertiesResponseBody = 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 = QueryDevicePropertiesResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomHeaders(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 QueryMeetingRoomRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
union_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomResponseBodyResultExtensionConfigAdvanceReservation(TeaModel):
|
|
def __init__(
|
|
self,
|
|
advance_book_time_format: str = None,
|
|
advance_reservation_time: int = None,
|
|
advance_reservation_time_unit: str = None,
|
|
):
|
|
self.advance_book_time_format = advance_book_time_format
|
|
self.advance_reservation_time = advance_reservation_time
|
|
self.advance_reservation_time_unit = advance_reservation_time_unit
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.advance_book_time_format is not None:
|
|
result['advanceBookTimeFormat'] = self.advance_book_time_format
|
|
if self.advance_reservation_time is not None:
|
|
result['advanceReservationTime'] = self.advance_reservation_time
|
|
if self.advance_reservation_time_unit is not None:
|
|
result['advanceReservationTimeUnit'] = self.advance_reservation_time_unit
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('advanceBookTimeFormat') is not None:
|
|
self.advance_book_time_format = m.get('advanceBookTimeFormat')
|
|
if m.get('advanceReservationTime') is not None:
|
|
self.advance_reservation_time = m.get('advanceReservationTime')
|
|
if m.get('advanceReservationTimeUnit') is not None:
|
|
self.advance_reservation_time_unit = m.get('advanceReservationTimeUnit')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomResponseBodyResultExtensionConfigReservationCloseDetail(TeaModel):
|
|
def __init__(
|
|
self,
|
|
close_reason: str = None,
|
|
contact_nick: str = None,
|
|
contact_union_id: str = None,
|
|
send_notify: bool = None,
|
|
task_end_time: int = None,
|
|
task_start_time: int = None,
|
|
):
|
|
self.close_reason = close_reason
|
|
self.contact_nick = contact_nick
|
|
self.contact_union_id = contact_union_id
|
|
self.send_notify = send_notify
|
|
self.task_end_time = task_end_time
|
|
self.task_start_time = task_start_time
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.close_reason is not None:
|
|
result['closeReason'] = self.close_reason
|
|
if self.contact_nick is not None:
|
|
result['contactNick'] = self.contact_nick
|
|
if self.contact_union_id is not None:
|
|
result['contactUnionId'] = self.contact_union_id
|
|
if self.send_notify is not None:
|
|
result['sendNotify'] = self.send_notify
|
|
if self.task_end_time is not None:
|
|
result['taskEndTime'] = self.task_end_time
|
|
if self.task_start_time is not None:
|
|
result['taskStartTime'] = self.task_start_time
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('closeReason') is not None:
|
|
self.close_reason = m.get('closeReason')
|
|
if m.get('contactNick') is not None:
|
|
self.contact_nick = m.get('contactNick')
|
|
if m.get('contactUnionId') is not None:
|
|
self.contact_union_id = m.get('contactUnionId')
|
|
if m.get('sendNotify') is not None:
|
|
self.send_notify = m.get('sendNotify')
|
|
if m.get('taskEndTime') is not None:
|
|
self.task_end_time = m.get('taskEndTime')
|
|
if m.get('taskStartTime') is not None:
|
|
self.task_start_time = m.get('taskStartTime')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomResponseBodyResultExtensionConfig(TeaModel):
|
|
def __init__(
|
|
self,
|
|
advance_reservation: QueryMeetingRoomResponseBodyResultExtensionConfigAdvanceReservation = None,
|
|
max_reservation_time_interval: int = None,
|
|
min_reservation_time_interval: int = None,
|
|
open_reservation: bool = None,
|
|
reservation_close_detail: QueryMeetingRoomResponseBodyResultExtensionConfigReservationCloseDetail = None,
|
|
):
|
|
self.advance_reservation = advance_reservation
|
|
self.max_reservation_time_interval = max_reservation_time_interval
|
|
self.min_reservation_time_interval = min_reservation_time_interval
|
|
self.open_reservation = open_reservation
|
|
self.reservation_close_detail = reservation_close_detail
|
|
|
|
def validate(self):
|
|
if self.advance_reservation:
|
|
self.advance_reservation.validate()
|
|
if self.reservation_close_detail:
|
|
self.reservation_close_detail.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.advance_reservation is not None:
|
|
result['advanceReservation'] = self.advance_reservation.to_map()
|
|
if self.max_reservation_time_interval is not None:
|
|
result['maxReservationTimeInterval'] = self.max_reservation_time_interval
|
|
if self.min_reservation_time_interval is not None:
|
|
result['minReservationTimeInterval'] = self.min_reservation_time_interval
|
|
if self.open_reservation is not None:
|
|
result['openReservation'] = self.open_reservation
|
|
if self.reservation_close_detail is not None:
|
|
result['reservationCloseDetail'] = self.reservation_close_detail.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('advanceReservation') is not None:
|
|
temp_model = QueryMeetingRoomResponseBodyResultExtensionConfigAdvanceReservation()
|
|
self.advance_reservation = temp_model.from_map(m['advanceReservation'])
|
|
if m.get('maxReservationTimeInterval') is not None:
|
|
self.max_reservation_time_interval = m.get('maxReservationTimeInterval')
|
|
if m.get('minReservationTimeInterval') is not None:
|
|
self.min_reservation_time_interval = m.get('minReservationTimeInterval')
|
|
if m.get('openReservation') is not None:
|
|
self.open_reservation = m.get('openReservation')
|
|
if m.get('reservationCloseDetail') is not None:
|
|
temp_model = QueryMeetingRoomResponseBodyResultExtensionConfigReservationCloseDetail()
|
|
self.reservation_close_detail = temp_model.from_map(m['reservationCloseDetail'])
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomResponseBodyResultReservationAuthorityAuthorizedMembers(TeaModel):
|
|
def __init__(
|
|
self,
|
|
member_id: str = None,
|
|
member_name: str = None,
|
|
member_type: str = None,
|
|
):
|
|
self.member_id = member_id
|
|
self.member_name = member_name
|
|
self.member_type = member_type
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.member_id is not None:
|
|
result['memberId'] = self.member_id
|
|
if self.member_name is not None:
|
|
result['memberName'] = self.member_name
|
|
if self.member_type is not None:
|
|
result['memberType'] = self.member_type
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('memberId') is not None:
|
|
self.member_id = m.get('memberId')
|
|
if m.get('memberName') is not None:
|
|
self.member_name = m.get('memberName')
|
|
if m.get('memberType') is not None:
|
|
self.member_type = m.get('memberType')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomResponseBodyResultReservationAuthority(TeaModel):
|
|
def __init__(
|
|
self,
|
|
authorized_members: List[QueryMeetingRoomResponseBodyResultReservationAuthorityAuthorizedMembers] = None,
|
|
):
|
|
self.authorized_members = authorized_members
|
|
|
|
def validate(self):
|
|
if self.authorized_members:
|
|
for k in self.authorized_members:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['authorizedMembers'] = []
|
|
if self.authorized_members is not None:
|
|
for k in self.authorized_members:
|
|
result['authorizedMembers'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.authorized_members = []
|
|
if m.get('authorizedMembers') is not None:
|
|
for k in m.get('authorizedMembers'):
|
|
temp_model = QueryMeetingRoomResponseBodyResultReservationAuthorityAuthorizedMembers()
|
|
self.authorized_members.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomResponseBodyResultRoomGroup(TeaModel):
|
|
def __init__(
|
|
self,
|
|
group_id: int = None,
|
|
group_name: str = None,
|
|
parent_id: int = None,
|
|
):
|
|
self.group_id = group_id
|
|
self.group_name = group_name
|
|
self.parent_id = parent_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.group_id is not None:
|
|
result['groupId'] = self.group_id
|
|
if self.group_name is not None:
|
|
result['groupName'] = self.group_name
|
|
if self.parent_id is not None:
|
|
result['parentId'] = self.parent_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('groupId') is not None:
|
|
self.group_id = m.get('groupId')
|
|
if m.get('groupName') is not None:
|
|
self.group_name = m.get('groupName')
|
|
if m.get('parentId') is not None:
|
|
self.parent_id = m.get('parentId')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomResponseBodyResultRoomLabels(TeaModel):
|
|
def __init__(
|
|
self,
|
|
label_id: int = None,
|
|
label_name: str = None,
|
|
):
|
|
self.label_id = label_id
|
|
self.label_name = label_name
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.label_id is not None:
|
|
result['labelId'] = self.label_id
|
|
if self.label_name is not None:
|
|
result['labelName'] = self.label_name
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('labelId') is not None:
|
|
self.label_id = m.get('labelId')
|
|
if m.get('labelName') is not None:
|
|
self.label_name = m.get('labelName')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomResponseBodyResultRoomLocation(TeaModel):
|
|
def __init__(
|
|
self,
|
|
desc: str = None,
|
|
title: str = None,
|
|
):
|
|
self.desc = desc
|
|
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.desc is not None:
|
|
result['desc'] = self.desc
|
|
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('desc') is not None:
|
|
self.desc = m.get('desc')
|
|
if m.get('title') is not None:
|
|
self.title = m.get('title')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
corp_id: str = None,
|
|
device_union_ids: List[str] = None,
|
|
enable_cycle_reservation: bool = None,
|
|
extension_config: QueryMeetingRoomResponseBodyResultExtensionConfig = None,
|
|
isv_room_id: str = None,
|
|
reservation_authority: QueryMeetingRoomResponseBodyResultReservationAuthority = None,
|
|
room_capacity: int = None,
|
|
room_group: QueryMeetingRoomResponseBodyResultRoomGroup = None,
|
|
room_id: str = None,
|
|
room_labels: List[QueryMeetingRoomResponseBodyResultRoomLabels] = None,
|
|
room_location: QueryMeetingRoomResponseBodyResultRoomLocation = None,
|
|
room_name: str = None,
|
|
room_picture: str = None,
|
|
room_staff_id: str = None,
|
|
room_status: int = None,
|
|
room_union_id: str = None,
|
|
):
|
|
self.corp_id = corp_id
|
|
self.device_union_ids = device_union_ids
|
|
self.enable_cycle_reservation = enable_cycle_reservation
|
|
self.extension_config = extension_config
|
|
self.isv_room_id = isv_room_id
|
|
self.reservation_authority = reservation_authority
|
|
self.room_capacity = room_capacity
|
|
self.room_group = room_group
|
|
self.room_id = room_id
|
|
self.room_labels = room_labels
|
|
self.room_location = room_location
|
|
self.room_name = room_name
|
|
self.room_picture = room_picture
|
|
self.room_staff_id = room_staff_id
|
|
self.room_status = room_status
|
|
self.room_union_id = room_union_id
|
|
|
|
def validate(self):
|
|
if self.extension_config:
|
|
self.extension_config.validate()
|
|
if self.reservation_authority:
|
|
self.reservation_authority.validate()
|
|
if self.room_group:
|
|
self.room_group.validate()
|
|
if self.room_labels:
|
|
for k in self.room_labels:
|
|
if k:
|
|
k.validate()
|
|
if self.room_location:
|
|
self.room_location.validate()
|
|
|
|
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.device_union_ids is not None:
|
|
result['deviceUnionIds'] = self.device_union_ids
|
|
if self.enable_cycle_reservation is not None:
|
|
result['enableCycleReservation'] = self.enable_cycle_reservation
|
|
if self.extension_config is not None:
|
|
result['extensionConfig'] = self.extension_config.to_map()
|
|
if self.isv_room_id is not None:
|
|
result['isvRoomId'] = self.isv_room_id
|
|
if self.reservation_authority is not None:
|
|
result['reservationAuthority'] = self.reservation_authority.to_map()
|
|
if self.room_capacity is not None:
|
|
result['roomCapacity'] = self.room_capacity
|
|
if self.room_group is not None:
|
|
result['roomGroup'] = self.room_group.to_map()
|
|
if self.room_id is not None:
|
|
result['roomId'] = self.room_id
|
|
result['roomLabels'] = []
|
|
if self.room_labels is not None:
|
|
for k in self.room_labels:
|
|
result['roomLabels'].append(k.to_map() if k else None)
|
|
if self.room_location is not None:
|
|
result['roomLocation'] = self.room_location.to_map()
|
|
if self.room_name is not None:
|
|
result['roomName'] = self.room_name
|
|
if self.room_picture is not None:
|
|
result['roomPicture'] = self.room_picture
|
|
if self.room_staff_id is not None:
|
|
result['roomStaffId'] = self.room_staff_id
|
|
if self.room_status is not None:
|
|
result['roomStatus'] = self.room_status
|
|
if self.room_union_id is not None:
|
|
result['roomUnionId'] = self.room_union_id
|
|
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('deviceUnionIds') is not None:
|
|
self.device_union_ids = m.get('deviceUnionIds')
|
|
if m.get('enableCycleReservation') is not None:
|
|
self.enable_cycle_reservation = m.get('enableCycleReservation')
|
|
if m.get('extensionConfig') is not None:
|
|
temp_model = QueryMeetingRoomResponseBodyResultExtensionConfig()
|
|
self.extension_config = temp_model.from_map(m['extensionConfig'])
|
|
if m.get('isvRoomId') is not None:
|
|
self.isv_room_id = m.get('isvRoomId')
|
|
if m.get('reservationAuthority') is not None:
|
|
temp_model = QueryMeetingRoomResponseBodyResultReservationAuthority()
|
|
self.reservation_authority = temp_model.from_map(m['reservationAuthority'])
|
|
if m.get('roomCapacity') is not None:
|
|
self.room_capacity = m.get('roomCapacity')
|
|
if m.get('roomGroup') is not None:
|
|
temp_model = QueryMeetingRoomResponseBodyResultRoomGroup()
|
|
self.room_group = temp_model.from_map(m['roomGroup'])
|
|
if m.get('roomId') is not None:
|
|
self.room_id = m.get('roomId')
|
|
self.room_labels = []
|
|
if m.get('roomLabels') is not None:
|
|
for k in m.get('roomLabels'):
|
|
temp_model = QueryMeetingRoomResponseBodyResultRoomLabels()
|
|
self.room_labels.append(temp_model.from_map(k))
|
|
if m.get('roomLocation') is not None:
|
|
temp_model = QueryMeetingRoomResponseBodyResultRoomLocation()
|
|
self.room_location = temp_model.from_map(m['roomLocation'])
|
|
if m.get('roomName') is not None:
|
|
self.room_name = m.get('roomName')
|
|
if m.get('roomPicture') is not None:
|
|
self.room_picture = m.get('roomPicture')
|
|
if m.get('roomStaffId') is not None:
|
|
self.room_staff_id = m.get('roomStaffId')
|
|
if m.get('roomStatus') is not None:
|
|
self.room_status = m.get('roomStatus')
|
|
if m.get('roomUnionId') is not None:
|
|
self.room_union_id = m.get('roomUnionId')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: QueryMeetingRoomResponseBodyResult = None,
|
|
):
|
|
self.result = result
|
|
|
|
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()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('result') is not None:
|
|
temp_model = QueryMeetingRoomResponseBodyResult()
|
|
self.result = temp_model.from_map(m['result'])
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryMeetingRoomResponseBody = 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 = QueryMeetingRoomResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomControlPanelListHeaders(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 QueryMeetingRoomControlPanelListRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
max_results: int = None,
|
|
next_token: int = None,
|
|
room_id: str = None,
|
|
union_id: str = None,
|
|
):
|
|
self.max_results = max_results
|
|
self.next_token = next_token
|
|
self.room_id = room_id
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.max_results is not None:
|
|
result['maxResults'] = self.max_results
|
|
if self.next_token is not None:
|
|
result['nextToken'] = self.next_token
|
|
if self.room_id is not None:
|
|
result['roomId'] = self.room_id
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('maxResults') is not None:
|
|
self.max_results = m.get('maxResults')
|
|
if m.get('nextToken') is not None:
|
|
self.next_token = m.get('nextToken')
|
|
if m.get('roomId') is not None:
|
|
self.room_id = m.get('roomId')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomControlPanelListResponseBodyResultRoomIotConfig(TeaModel):
|
|
def __init__(
|
|
self,
|
|
en_name: str = None,
|
|
icon: str = None,
|
|
name: str = None,
|
|
show_time: int = None,
|
|
sort: int = None,
|
|
url: str = None,
|
|
):
|
|
self.en_name = en_name
|
|
self.icon = icon
|
|
self.name = name
|
|
self.show_time = show_time
|
|
self.sort = sort
|
|
self.url = url
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.en_name is not None:
|
|
result['enName'] = self.en_name
|
|
if self.icon is not None:
|
|
result['icon'] = self.icon
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.show_time is not None:
|
|
result['showTime'] = self.show_time
|
|
if self.sort is not None:
|
|
result['sort'] = self.sort
|
|
if self.url is not None:
|
|
result['url'] = self.url
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('enName') is not None:
|
|
self.en_name = m.get('enName')
|
|
if m.get('icon') is not None:
|
|
self.icon = m.get('icon')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('showTime') is not None:
|
|
self.show_time = m.get('showTime')
|
|
if m.get('sort') is not None:
|
|
self.sort = m.get('sort')
|
|
if m.get('url') is not None:
|
|
self.url = m.get('url')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomControlPanelListResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
room_id: str = None,
|
|
room_iot_config: List[QueryMeetingRoomControlPanelListResponseBodyResultRoomIotConfig] = None,
|
|
):
|
|
self.room_id = room_id
|
|
self.room_iot_config = room_iot_config
|
|
|
|
def validate(self):
|
|
if self.room_iot_config:
|
|
for k in self.room_iot_config:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.room_id is not None:
|
|
result['roomId'] = self.room_id
|
|
result['roomIotConfig'] = []
|
|
if self.room_iot_config is not None:
|
|
for k in self.room_iot_config:
|
|
result['roomIotConfig'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('roomId') is not None:
|
|
self.room_id = m.get('roomId')
|
|
self.room_iot_config = []
|
|
if m.get('roomIotConfig') is not None:
|
|
for k in m.get('roomIotConfig'):
|
|
temp_model = QueryMeetingRoomControlPanelListResponseBodyResultRoomIotConfig()
|
|
self.room_iot_config.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomControlPanelListResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
has_more: bool = None,
|
|
next_token: int = None,
|
|
result: List[QueryMeetingRoomControlPanelListResponseBodyResult] = None,
|
|
total_count: int = None,
|
|
):
|
|
self.has_more = has_more
|
|
self.next_token = next_token
|
|
self.result = result
|
|
self.total_count = total_count
|
|
|
|
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()
|
|
if self.has_more is not None:
|
|
result['hasMore'] = self.has_more
|
|
if self.next_token is not None:
|
|
result['nextToken'] = self.next_token
|
|
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.total_count is not None:
|
|
result['totalCount'] = self.total_count
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('hasMore') is not None:
|
|
self.has_more = m.get('hasMore')
|
|
if m.get('nextToken') is not None:
|
|
self.next_token = m.get('nextToken')
|
|
self.result = []
|
|
if m.get('result') is not None:
|
|
for k in m.get('result'):
|
|
temp_model = QueryMeetingRoomControlPanelListResponseBodyResult()
|
|
self.result.append(temp_model.from_map(k))
|
|
if m.get('totalCount') is not None:
|
|
self.total_count = m.get('totalCount')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomControlPanelListResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryMeetingRoomControlPanelListResponseBody = 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 = QueryMeetingRoomControlPanelListResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomDeviceHeaders(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 QueryMeetingRoomDeviceRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
device_id: str = None,
|
|
device_union_id: str = None,
|
|
operator_union_id: str = None,
|
|
):
|
|
self.device_id = device_id
|
|
self.device_union_id = device_union_id
|
|
# This parameter is required.
|
|
self.operator_union_id = operator_union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.device_id is not None:
|
|
result['deviceId'] = self.device_id
|
|
if self.device_union_id is not None:
|
|
result['deviceUnionId'] = self.device_union_id
|
|
if self.operator_union_id is not None:
|
|
result['operatorUnionId'] = self.operator_union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('deviceId') is not None:
|
|
self.device_id = m.get('deviceId')
|
|
if m.get('deviceUnionId') is not None:
|
|
self.device_union_id = m.get('deviceUnionId')
|
|
if m.get('operatorUnionId') is not None:
|
|
self.operator_union_id = m.get('operatorUnionId')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomDeviceResponseBodyResultControllers(TeaModel):
|
|
def __init__(
|
|
self,
|
|
corp_id: str = None,
|
|
device_id: str = None,
|
|
device_mac: str = None,
|
|
device_model: str = None,
|
|
device_name: str = None,
|
|
device_service_id: int = None,
|
|
device_sn: str = None,
|
|
device_status: str = None,
|
|
device_type: str = None,
|
|
device_union_id: str = None,
|
|
open_room_id: str = None,
|
|
share_code: str = None,
|
|
):
|
|
self.corp_id = corp_id
|
|
self.device_id = device_id
|
|
self.device_mac = device_mac
|
|
self.device_model = device_model
|
|
self.device_name = device_name
|
|
self.device_service_id = device_service_id
|
|
self.device_sn = device_sn
|
|
self.device_status = device_status
|
|
self.device_type = device_type
|
|
self.device_union_id = device_union_id
|
|
self.open_room_id = open_room_id
|
|
self.share_code = share_code
|
|
|
|
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.device_id is not None:
|
|
result['deviceId'] = self.device_id
|
|
if self.device_mac is not None:
|
|
result['deviceMac'] = self.device_mac
|
|
if self.device_model is not None:
|
|
result['deviceModel'] = self.device_model
|
|
if self.device_name is not None:
|
|
result['deviceName'] = self.device_name
|
|
if self.device_service_id is not None:
|
|
result['deviceServiceId'] = self.device_service_id
|
|
if self.device_sn is not None:
|
|
result['deviceSn'] = self.device_sn
|
|
if self.device_status is not None:
|
|
result['deviceStatus'] = self.device_status
|
|
if self.device_type is not None:
|
|
result['deviceType'] = self.device_type
|
|
if self.device_union_id is not None:
|
|
result['deviceUnionId'] = self.device_union_id
|
|
if self.open_room_id is not None:
|
|
result['openRoomId'] = self.open_room_id
|
|
if self.share_code is not None:
|
|
result['shareCode'] = self.share_code
|
|
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('deviceId') is not None:
|
|
self.device_id = m.get('deviceId')
|
|
if m.get('deviceMac') is not None:
|
|
self.device_mac = m.get('deviceMac')
|
|
if m.get('deviceModel') is not None:
|
|
self.device_model = m.get('deviceModel')
|
|
if m.get('deviceName') is not None:
|
|
self.device_name = m.get('deviceName')
|
|
if m.get('deviceServiceId') is not None:
|
|
self.device_service_id = m.get('deviceServiceId')
|
|
if m.get('deviceSn') is not None:
|
|
self.device_sn = m.get('deviceSn')
|
|
if m.get('deviceStatus') is not None:
|
|
self.device_status = m.get('deviceStatus')
|
|
if m.get('deviceType') is not None:
|
|
self.device_type = m.get('deviceType')
|
|
if m.get('deviceUnionId') is not None:
|
|
self.device_union_id = m.get('deviceUnionId')
|
|
if m.get('openRoomId') is not None:
|
|
self.open_room_id = m.get('openRoomId')
|
|
if m.get('shareCode') is not None:
|
|
self.share_code = m.get('shareCode')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomDeviceResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
active_time: int = None,
|
|
controllers: List[QueryMeetingRoomDeviceResponseBodyResultControllers] = None,
|
|
corp_id: str = None,
|
|
creator_union_id: str = None,
|
|
dev_camera: str = None,
|
|
dev_hdmi: str = None,
|
|
dev_mic: str = None,
|
|
dev_mirror: str = None,
|
|
dev_net_ip: str = None,
|
|
dev_net_type: str = None,
|
|
dev_voice: str = None,
|
|
dev_wifi_mac: str = None,
|
|
dev_wire_mac: str = None,
|
|
device_id: str = None,
|
|
device_mac: str = None,
|
|
device_model: str = None,
|
|
device_name: str = None,
|
|
device_service_id: int = None,
|
|
device_sn: str = None,
|
|
device_status: str = None,
|
|
device_type: str = None,
|
|
device_union_id: str = None,
|
|
firmware_version: str = None,
|
|
open_room_id: str = None,
|
|
room_name: str = None,
|
|
share_code: str = None,
|
|
sip_account_name: str = None,
|
|
software_version: str = None,
|
|
):
|
|
self.active_time = active_time
|
|
self.controllers = controllers
|
|
self.corp_id = corp_id
|
|
self.creator_union_id = creator_union_id
|
|
self.dev_camera = dev_camera
|
|
self.dev_hdmi = dev_hdmi
|
|
self.dev_mic = dev_mic
|
|
self.dev_mirror = dev_mirror
|
|
self.dev_net_ip = dev_net_ip
|
|
self.dev_net_type = dev_net_type
|
|
self.dev_voice = dev_voice
|
|
self.dev_wifi_mac = dev_wifi_mac
|
|
self.dev_wire_mac = dev_wire_mac
|
|
self.device_id = device_id
|
|
self.device_mac = device_mac
|
|
self.device_model = device_model
|
|
self.device_name = device_name
|
|
self.device_service_id = device_service_id
|
|
self.device_sn = device_sn
|
|
self.device_status = device_status
|
|
self.device_type = device_type
|
|
self.device_union_id = device_union_id
|
|
self.firmware_version = firmware_version
|
|
self.open_room_id = open_room_id
|
|
self.room_name = room_name
|
|
self.share_code = share_code
|
|
self.sip_account_name = sip_account_name
|
|
self.software_version = software_version
|
|
|
|
def validate(self):
|
|
if self.controllers:
|
|
for k in self.controllers:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.active_time is not None:
|
|
result['activeTime'] = self.active_time
|
|
result['controllers'] = []
|
|
if self.controllers is not None:
|
|
for k in self.controllers:
|
|
result['controllers'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
if self.creator_union_id is not None:
|
|
result['creatorUnionId'] = self.creator_union_id
|
|
if self.dev_camera is not None:
|
|
result['devCamera'] = self.dev_camera
|
|
if self.dev_hdmi is not None:
|
|
result['devHdmi'] = self.dev_hdmi
|
|
if self.dev_mic is not None:
|
|
result['devMic'] = self.dev_mic
|
|
if self.dev_mirror is not None:
|
|
result['devMirror'] = self.dev_mirror
|
|
if self.dev_net_ip is not None:
|
|
result['devNetIp'] = self.dev_net_ip
|
|
if self.dev_net_type is not None:
|
|
result['devNetType'] = self.dev_net_type
|
|
if self.dev_voice is not None:
|
|
result['devVoice'] = self.dev_voice
|
|
if self.dev_wifi_mac is not None:
|
|
result['devWifiMac'] = self.dev_wifi_mac
|
|
if self.dev_wire_mac is not None:
|
|
result['devWireMac'] = self.dev_wire_mac
|
|
if self.device_id is not None:
|
|
result['deviceId'] = self.device_id
|
|
if self.device_mac is not None:
|
|
result['deviceMac'] = self.device_mac
|
|
if self.device_model is not None:
|
|
result['deviceModel'] = self.device_model
|
|
if self.device_name is not None:
|
|
result['deviceName'] = self.device_name
|
|
if self.device_service_id is not None:
|
|
result['deviceServiceId'] = self.device_service_id
|
|
if self.device_sn is not None:
|
|
result['deviceSn'] = self.device_sn
|
|
if self.device_status is not None:
|
|
result['deviceStatus'] = self.device_status
|
|
if self.device_type is not None:
|
|
result['deviceType'] = self.device_type
|
|
if self.device_union_id is not None:
|
|
result['deviceUnionId'] = self.device_union_id
|
|
if self.firmware_version is not None:
|
|
result['firmwareVersion'] = self.firmware_version
|
|
if self.open_room_id is not None:
|
|
result['openRoomId'] = self.open_room_id
|
|
if self.room_name is not None:
|
|
result['roomName'] = self.room_name
|
|
if self.share_code is not None:
|
|
result['shareCode'] = self.share_code
|
|
if self.sip_account_name is not None:
|
|
result['sipAccountName'] = self.sip_account_name
|
|
if self.software_version is not None:
|
|
result['softwareVersion'] = self.software_version
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('activeTime') is not None:
|
|
self.active_time = m.get('activeTime')
|
|
self.controllers = []
|
|
if m.get('controllers') is not None:
|
|
for k in m.get('controllers'):
|
|
temp_model = QueryMeetingRoomDeviceResponseBodyResultControllers()
|
|
self.controllers.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
if m.get('creatorUnionId') is not None:
|
|
self.creator_union_id = m.get('creatorUnionId')
|
|
if m.get('devCamera') is not None:
|
|
self.dev_camera = m.get('devCamera')
|
|
if m.get('devHdmi') is not None:
|
|
self.dev_hdmi = m.get('devHdmi')
|
|
if m.get('devMic') is not None:
|
|
self.dev_mic = m.get('devMic')
|
|
if m.get('devMirror') is not None:
|
|
self.dev_mirror = m.get('devMirror')
|
|
if m.get('devNetIp') is not None:
|
|
self.dev_net_ip = m.get('devNetIp')
|
|
if m.get('devNetType') is not None:
|
|
self.dev_net_type = m.get('devNetType')
|
|
if m.get('devVoice') is not None:
|
|
self.dev_voice = m.get('devVoice')
|
|
if m.get('devWifiMac') is not None:
|
|
self.dev_wifi_mac = m.get('devWifiMac')
|
|
if m.get('devWireMac') is not None:
|
|
self.dev_wire_mac = m.get('devWireMac')
|
|
if m.get('deviceId') is not None:
|
|
self.device_id = m.get('deviceId')
|
|
if m.get('deviceMac') is not None:
|
|
self.device_mac = m.get('deviceMac')
|
|
if m.get('deviceModel') is not None:
|
|
self.device_model = m.get('deviceModel')
|
|
if m.get('deviceName') is not None:
|
|
self.device_name = m.get('deviceName')
|
|
if m.get('deviceServiceId') is not None:
|
|
self.device_service_id = m.get('deviceServiceId')
|
|
if m.get('deviceSn') is not None:
|
|
self.device_sn = m.get('deviceSn')
|
|
if m.get('deviceStatus') is not None:
|
|
self.device_status = m.get('deviceStatus')
|
|
if m.get('deviceType') is not None:
|
|
self.device_type = m.get('deviceType')
|
|
if m.get('deviceUnionId') is not None:
|
|
self.device_union_id = m.get('deviceUnionId')
|
|
if m.get('firmwareVersion') is not None:
|
|
self.firmware_version = m.get('firmwareVersion')
|
|
if m.get('openRoomId') is not None:
|
|
self.open_room_id = m.get('openRoomId')
|
|
if m.get('roomName') is not None:
|
|
self.room_name = m.get('roomName')
|
|
if m.get('shareCode') is not None:
|
|
self.share_code = m.get('shareCode')
|
|
if m.get('sipAccountName') is not None:
|
|
self.sip_account_name = m.get('sipAccountName')
|
|
if m.get('softwareVersion') is not None:
|
|
self.software_version = m.get('softwareVersion')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomDeviceResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: QueryMeetingRoomDeviceResponseBodyResult = None,
|
|
):
|
|
self.result = result
|
|
|
|
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()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('result') is not None:
|
|
temp_model = QueryMeetingRoomDeviceResponseBodyResult()
|
|
self.result = temp_model.from_map(m['result'])
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomDeviceResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryMeetingRoomDeviceResponseBody = 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 = QueryMeetingRoomDeviceResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomGroupHeaders(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 QueryMeetingRoomGroupRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
union_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomGroupResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
group_id: int = None,
|
|
group_name: str = None,
|
|
parent_id: int = None,
|
|
):
|
|
self.group_id = group_id
|
|
self.group_name = group_name
|
|
self.parent_id = parent_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.group_id is not None:
|
|
result['groupId'] = self.group_id
|
|
if self.group_name is not None:
|
|
result['groupName'] = self.group_name
|
|
if self.parent_id is not None:
|
|
result['parentId'] = self.parent_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('groupId') is not None:
|
|
self.group_id = m.get('groupId')
|
|
if m.get('groupName') is not None:
|
|
self.group_name = m.get('groupName')
|
|
if m.get('parentId') is not None:
|
|
self.parent_id = m.get('parentId')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomGroupResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryMeetingRoomGroupResponseBody = 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 = QueryMeetingRoomGroupResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomGroupListHeaders(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 QueryMeetingRoomGroupListRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
union_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomGroupListResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
group_id: int = None,
|
|
group_name: str = None,
|
|
parent_id: int = None,
|
|
):
|
|
self.group_id = group_id
|
|
self.group_name = group_name
|
|
self.parent_id = parent_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.group_id is not None:
|
|
result['groupId'] = self.group_id
|
|
if self.group_name is not None:
|
|
result['groupName'] = self.group_name
|
|
if self.parent_id is not None:
|
|
result['parentId'] = self.parent_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('groupId') is not None:
|
|
self.group_id = m.get('groupId')
|
|
if m.get('groupName') is not None:
|
|
self.group_name = m.get('groupName')
|
|
if m.get('parentId') is not None:
|
|
self.parent_id = m.get('parentId')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomGroupListResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: List[QueryMeetingRoomGroupListResponseBodyResult] = None,
|
|
):
|
|
self.result = result
|
|
|
|
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)
|
|
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 = QueryMeetingRoomGroupListResponseBodyResult()
|
|
self.result.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomGroupListResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryMeetingRoomGroupListResponseBody = 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 = QueryMeetingRoomGroupListResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomListHeaders(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 QueryMeetingRoomListRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
max_results: int = None,
|
|
next_token: int = None,
|
|
union_id: str = None,
|
|
):
|
|
self.max_results = max_results
|
|
self.next_token = next_token
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.max_results is not None:
|
|
result['maxResults'] = self.max_results
|
|
if self.next_token is not None:
|
|
result['nextToken'] = self.next_token
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('maxResults') is not None:
|
|
self.max_results = m.get('maxResults')
|
|
if m.get('nextToken') is not None:
|
|
self.next_token = m.get('nextToken')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomListResponseBodyResultRoomGroup(TeaModel):
|
|
def __init__(
|
|
self,
|
|
group_id: int = None,
|
|
group_name: str = None,
|
|
parent_id: int = None,
|
|
):
|
|
self.group_id = group_id
|
|
self.group_name = group_name
|
|
self.parent_id = parent_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.group_id is not None:
|
|
result['groupId'] = self.group_id
|
|
if self.group_name is not None:
|
|
result['groupName'] = self.group_name
|
|
if self.parent_id is not None:
|
|
result['parentId'] = self.parent_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('groupId') is not None:
|
|
self.group_id = m.get('groupId')
|
|
if m.get('groupName') is not None:
|
|
self.group_name = m.get('groupName')
|
|
if m.get('parentId') is not None:
|
|
self.parent_id = m.get('parentId')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomListResponseBodyResultRoomLabels(TeaModel):
|
|
def __init__(
|
|
self,
|
|
label_id: int = None,
|
|
label_name: str = None,
|
|
):
|
|
self.label_id = label_id
|
|
self.label_name = label_name
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.label_id is not None:
|
|
result['labelId'] = self.label_id
|
|
if self.label_name is not None:
|
|
result['labelName'] = self.label_name
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('labelId') is not None:
|
|
self.label_id = m.get('labelId')
|
|
if m.get('labelName') is not None:
|
|
self.label_name = m.get('labelName')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomListResponseBodyResultRoomLocation(TeaModel):
|
|
def __init__(
|
|
self,
|
|
desc: str = None,
|
|
title: str = None,
|
|
):
|
|
self.desc = desc
|
|
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.desc is not None:
|
|
result['desc'] = self.desc
|
|
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('desc') is not None:
|
|
self.desc = m.get('desc')
|
|
if m.get('title') is not None:
|
|
self.title = m.get('title')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomListResponseBodyResult(TeaModel):
|
|
def __init__(
|
|
self,
|
|
corp_id: str = None,
|
|
isv_room_id: str = None,
|
|
room_capacity: int = None,
|
|
room_group: QueryMeetingRoomListResponseBodyResultRoomGroup = None,
|
|
room_id: str = None,
|
|
room_labels: List[QueryMeetingRoomListResponseBodyResultRoomLabels] = None,
|
|
room_location: QueryMeetingRoomListResponseBodyResultRoomLocation = None,
|
|
room_name: str = None,
|
|
room_picture: str = None,
|
|
room_staff_id: str = None,
|
|
room_status: int = None,
|
|
):
|
|
self.corp_id = corp_id
|
|
self.isv_room_id = isv_room_id
|
|
self.room_capacity = room_capacity
|
|
self.room_group = room_group
|
|
self.room_id = room_id
|
|
self.room_labels = room_labels
|
|
self.room_location = room_location
|
|
self.room_name = room_name
|
|
self.room_picture = room_picture
|
|
self.room_staff_id = room_staff_id
|
|
self.room_status = room_status
|
|
|
|
def validate(self):
|
|
if self.room_group:
|
|
self.room_group.validate()
|
|
if self.room_labels:
|
|
for k in self.room_labels:
|
|
if k:
|
|
k.validate()
|
|
if self.room_location:
|
|
self.room_location.validate()
|
|
|
|
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.isv_room_id is not None:
|
|
result['isvRoomId'] = self.isv_room_id
|
|
if self.room_capacity is not None:
|
|
result['roomCapacity'] = self.room_capacity
|
|
if self.room_group is not None:
|
|
result['roomGroup'] = self.room_group.to_map()
|
|
if self.room_id is not None:
|
|
result['roomId'] = self.room_id
|
|
result['roomLabels'] = []
|
|
if self.room_labels is not None:
|
|
for k in self.room_labels:
|
|
result['roomLabels'].append(k.to_map() if k else None)
|
|
if self.room_location is not None:
|
|
result['roomLocation'] = self.room_location.to_map()
|
|
if self.room_name is not None:
|
|
result['roomName'] = self.room_name
|
|
if self.room_picture is not None:
|
|
result['roomPicture'] = self.room_picture
|
|
if self.room_staff_id is not None:
|
|
result['roomStaffId'] = self.room_staff_id
|
|
if self.room_status is not None:
|
|
result['roomStatus'] = self.room_status
|
|
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('isvRoomId') is not None:
|
|
self.isv_room_id = m.get('isvRoomId')
|
|
if m.get('roomCapacity') is not None:
|
|
self.room_capacity = m.get('roomCapacity')
|
|
if m.get('roomGroup') is not None:
|
|
temp_model = QueryMeetingRoomListResponseBodyResultRoomGroup()
|
|
self.room_group = temp_model.from_map(m['roomGroup'])
|
|
if m.get('roomId') is not None:
|
|
self.room_id = m.get('roomId')
|
|
self.room_labels = []
|
|
if m.get('roomLabels') is not None:
|
|
for k in m.get('roomLabels'):
|
|
temp_model = QueryMeetingRoomListResponseBodyResultRoomLabels()
|
|
self.room_labels.append(temp_model.from_map(k))
|
|
if m.get('roomLocation') is not None:
|
|
temp_model = QueryMeetingRoomListResponseBodyResultRoomLocation()
|
|
self.room_location = temp_model.from_map(m['roomLocation'])
|
|
if m.get('roomName') is not None:
|
|
self.room_name = m.get('roomName')
|
|
if m.get('roomPicture') is not None:
|
|
self.room_picture = m.get('roomPicture')
|
|
if m.get('roomStaffId') is not None:
|
|
self.room_staff_id = m.get('roomStaffId')
|
|
if m.get('roomStatus') is not None:
|
|
self.room_status = m.get('roomStatus')
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomListResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
has_more: bool = None,
|
|
next_token: int = None,
|
|
result: List[QueryMeetingRoomListResponseBodyResult] = None,
|
|
):
|
|
self.has_more = has_more
|
|
self.next_token = next_token
|
|
self.result = result
|
|
|
|
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()
|
|
if self.has_more is not None:
|
|
result['hasMore'] = self.has_more
|
|
if self.next_token is not None:
|
|
result['nextToken'] = self.next_token
|
|
result['result'] = []
|
|
if self.result is not None:
|
|
for k in self.result:
|
|
result['result'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('hasMore') is not None:
|
|
self.has_more = m.get('hasMore')
|
|
if m.get('nextToken') is not None:
|
|
self.next_token = m.get('nextToken')
|
|
self.result = []
|
|
if m.get('result') is not None:
|
|
for k in m.get('result'):
|
|
temp_model = QueryMeetingRoomListResponseBodyResult()
|
|
self.result.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class QueryMeetingRoomListResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryMeetingRoomListResponseBody = 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 = QueryMeetingRoomListResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class RemoveSuperUserMeetingRoomHeaders(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 RemoveSuperUserMeetingRoomRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
room_id: str = None,
|
|
union_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.room_id = room_id
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.room_id is not None:
|
|
result['roomId'] = self.room_id
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('roomId') is not None:
|
|
self.room_id = m.get('roomId')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class RemoveSuperUserMeetingRoomResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: bool = 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 RemoveSuperUserMeetingRoomResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: RemoveSuperUserMeetingRoomResponseBody = 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 = RemoveSuperUserMeetingRoomResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class SetSuperUserMeetingRoomHeaders(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 SetSuperUserMeetingRoomRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
dept_id_white_list: List[int] = None,
|
|
room_id: str = None,
|
|
union_id: str = None,
|
|
user_id_white_list: List[str] = None,
|
|
):
|
|
self.dept_id_white_list = dept_id_white_list
|
|
# This parameter is required.
|
|
self.room_id = room_id
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
self.user_id_white_list = user_id_white_list
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.dept_id_white_list is not None:
|
|
result['deptIdWhiteList'] = self.dept_id_white_list
|
|
if self.room_id is not None:
|
|
result['roomId'] = self.room_id
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
if self.user_id_white_list is not None:
|
|
result['userIdWhiteList'] = self.user_id_white_list
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('deptIdWhiteList') is not None:
|
|
self.dept_id_white_list = m.get('deptIdWhiteList')
|
|
if m.get('roomId') is not None:
|
|
self.room_id = m.get('roomId')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
if m.get('userIdWhiteList') is not None:
|
|
self.user_id_white_list = m.get('userIdWhiteList')
|
|
return self
|
|
|
|
|
|
class SetSuperUserMeetingRoomResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: bool = 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 SetSuperUserMeetingRoomResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: SetSuperUserMeetingRoomResponseBody = 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 = SetSuperUserMeetingRoomResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class UpdateDeviceCustomTemplateHeaders(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 UpdateDeviceCustomTemplateRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
bg_img_list: List[str] = None,
|
|
bg_type: int = None,
|
|
bg_url: str = None,
|
|
custom_doc: str = None,
|
|
desensitize_user_name: bool = None,
|
|
device_union_ids: List[str] = None,
|
|
group_ids: List[int] = None,
|
|
hide_server_code_when_projecting: bool = None,
|
|
instruction: bool = None,
|
|
is_pic_top: int = None,
|
|
logo: str = None,
|
|
org_name: str = None,
|
|
picture_play_interval: int = None,
|
|
room_ids: List[str] = None,
|
|
show_calendar_card: bool = None,
|
|
show_calendar_title: bool = None,
|
|
show_function_card: bool = None,
|
|
template_id: int = None,
|
|
template_name: str = None,
|
|
):
|
|
self.bg_img_list = bg_img_list
|
|
self.bg_type = bg_type
|
|
self.bg_url = bg_url
|
|
self.custom_doc = custom_doc
|
|
self.desensitize_user_name = desensitize_user_name
|
|
self.device_union_ids = device_union_ids
|
|
self.group_ids = group_ids
|
|
self.hide_server_code_when_projecting = hide_server_code_when_projecting
|
|
self.instruction = instruction
|
|
self.is_pic_top = is_pic_top
|
|
self.logo = logo
|
|
self.org_name = org_name
|
|
self.picture_play_interval = picture_play_interval
|
|
self.room_ids = room_ids
|
|
self.show_calendar_card = show_calendar_card
|
|
self.show_calendar_title = show_calendar_title
|
|
self.show_function_card = show_function_card
|
|
# This parameter is required.
|
|
self.template_id = template_id
|
|
# This parameter is required.
|
|
self.template_name = template_name
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.bg_img_list is not None:
|
|
result['bgImgList'] = self.bg_img_list
|
|
if self.bg_type is not None:
|
|
result['bgType'] = self.bg_type
|
|
if self.bg_url is not None:
|
|
result['bgUrl'] = self.bg_url
|
|
if self.custom_doc is not None:
|
|
result['customDoc'] = self.custom_doc
|
|
if self.desensitize_user_name is not None:
|
|
result['desensitizeUserName'] = self.desensitize_user_name
|
|
if self.device_union_ids is not None:
|
|
result['deviceUnionIds'] = self.device_union_ids
|
|
if self.group_ids is not None:
|
|
result['groupIds'] = self.group_ids
|
|
if self.hide_server_code_when_projecting is not None:
|
|
result['hideServerCodeWhenProjecting'] = self.hide_server_code_when_projecting
|
|
if self.instruction is not None:
|
|
result['instruction'] = self.instruction
|
|
if self.is_pic_top is not None:
|
|
result['isPicTop'] = self.is_pic_top
|
|
if self.logo is not None:
|
|
result['logo'] = self.logo
|
|
if self.org_name is not None:
|
|
result['orgName'] = self.org_name
|
|
if self.picture_play_interval is not None:
|
|
result['picturePlayInterval'] = self.picture_play_interval
|
|
if self.room_ids is not None:
|
|
result['roomIds'] = self.room_ids
|
|
if self.show_calendar_card is not None:
|
|
result['showCalendarCard'] = self.show_calendar_card
|
|
if self.show_calendar_title is not None:
|
|
result['showCalendarTitle'] = self.show_calendar_title
|
|
if self.show_function_card is not None:
|
|
result['showFunctionCard'] = self.show_function_card
|
|
if self.template_id is not None:
|
|
result['templateId'] = self.template_id
|
|
if self.template_name is not None:
|
|
result['templateName'] = self.template_name
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('bgImgList') is not None:
|
|
self.bg_img_list = m.get('bgImgList')
|
|
if m.get('bgType') is not None:
|
|
self.bg_type = m.get('bgType')
|
|
if m.get('bgUrl') is not None:
|
|
self.bg_url = m.get('bgUrl')
|
|
if m.get('customDoc') is not None:
|
|
self.custom_doc = m.get('customDoc')
|
|
if m.get('desensitizeUserName') is not None:
|
|
self.desensitize_user_name = m.get('desensitizeUserName')
|
|
if m.get('deviceUnionIds') is not None:
|
|
self.device_union_ids = m.get('deviceUnionIds')
|
|
if m.get('groupIds') is not None:
|
|
self.group_ids = m.get('groupIds')
|
|
if m.get('hideServerCodeWhenProjecting') is not None:
|
|
self.hide_server_code_when_projecting = m.get('hideServerCodeWhenProjecting')
|
|
if m.get('instruction') is not None:
|
|
self.instruction = m.get('instruction')
|
|
if m.get('isPicTop') is not None:
|
|
self.is_pic_top = m.get('isPicTop')
|
|
if m.get('logo') is not None:
|
|
self.logo = m.get('logo')
|
|
if m.get('orgName') is not None:
|
|
self.org_name = m.get('orgName')
|
|
if m.get('picturePlayInterval') is not None:
|
|
self.picture_play_interval = m.get('picturePlayInterval')
|
|
if m.get('roomIds') is not None:
|
|
self.room_ids = m.get('roomIds')
|
|
if m.get('showCalendarCard') is not None:
|
|
self.show_calendar_card = m.get('showCalendarCard')
|
|
if m.get('showCalendarTitle') is not None:
|
|
self.show_calendar_title = m.get('showCalendarTitle')
|
|
if m.get('showFunctionCard') is not None:
|
|
self.show_function_card = m.get('showFunctionCard')
|
|
if m.get('templateId') is not None:
|
|
self.template_id = m.get('templateId')
|
|
if m.get('templateName') is not None:
|
|
self.template_name = m.get('templateName')
|
|
return self
|
|
|
|
|
|
class UpdateDeviceCustomTemplateResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: bool = 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 UpdateDeviceCustomTemplateResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: UpdateDeviceCustomTemplateResponseBody = 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 = UpdateDeviceCustomTemplateResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class UpdateMeetingRoomHeaders(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 UpdateMeetingRoomRequestReservationAuthorityAuthorizedMembers(TeaModel):
|
|
def __init__(
|
|
self,
|
|
member_id: str = None,
|
|
member_name: str = None,
|
|
member_type: str = None,
|
|
):
|
|
self.member_id = member_id
|
|
self.member_name = member_name
|
|
self.member_type = member_type
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.member_id is not None:
|
|
result['memberId'] = self.member_id
|
|
if self.member_name is not None:
|
|
result['memberName'] = self.member_name
|
|
if self.member_type is not None:
|
|
result['memberType'] = self.member_type
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('memberId') is not None:
|
|
self.member_id = m.get('memberId')
|
|
if m.get('memberName') is not None:
|
|
self.member_name = m.get('memberName')
|
|
if m.get('memberType') is not None:
|
|
self.member_type = m.get('memberType')
|
|
return self
|
|
|
|
|
|
class UpdateMeetingRoomRequestReservationAuthority(TeaModel):
|
|
def __init__(
|
|
self,
|
|
authorized_members: List[UpdateMeetingRoomRequestReservationAuthorityAuthorizedMembers] = None,
|
|
):
|
|
self.authorized_members = authorized_members
|
|
|
|
def validate(self):
|
|
if self.authorized_members:
|
|
for k in self.authorized_members:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['authorizedMembers'] = []
|
|
if self.authorized_members is not None:
|
|
for k in self.authorized_members:
|
|
result['authorizedMembers'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.authorized_members = []
|
|
if m.get('authorizedMembers') is not None:
|
|
for k in m.get('authorizedMembers'):
|
|
temp_model = UpdateMeetingRoomRequestReservationAuthorityAuthorizedMembers()
|
|
self.authorized_members.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class UpdateMeetingRoomRequestRoomLocation(TeaModel):
|
|
def __init__(
|
|
self,
|
|
desc: str = None,
|
|
title: str = None,
|
|
):
|
|
self.desc = desc
|
|
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.desc is not None:
|
|
result['desc'] = self.desc
|
|
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('desc') is not None:
|
|
self.desc = m.get('desc')
|
|
if m.get('title') is not None:
|
|
self.title = m.get('title')
|
|
return self
|
|
|
|
|
|
class UpdateMeetingRoomRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
enable_cycle_reservation: bool = None,
|
|
group_id: int = None,
|
|
isv_room_id: str = None,
|
|
open_reservation: bool = None,
|
|
reservation_authority: UpdateMeetingRoomRequestReservationAuthority = None,
|
|
room_capacity: int = None,
|
|
room_id: str = None,
|
|
room_label_ids: List[int] = None,
|
|
room_location: UpdateMeetingRoomRequestRoomLocation = None,
|
|
room_name: str = None,
|
|
room_picture: str = None,
|
|
room_status: int = None,
|
|
union_id: str = None,
|
|
):
|
|
self.enable_cycle_reservation = enable_cycle_reservation
|
|
self.group_id = group_id
|
|
self.isv_room_id = isv_room_id
|
|
self.open_reservation = open_reservation
|
|
self.reservation_authority = reservation_authority
|
|
self.room_capacity = room_capacity
|
|
# This parameter is required.
|
|
self.room_id = room_id
|
|
self.room_label_ids = room_label_ids
|
|
self.room_location = room_location
|
|
self.room_name = room_name
|
|
self.room_picture = room_picture
|
|
self.room_status = room_status
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
if self.reservation_authority:
|
|
self.reservation_authority.validate()
|
|
if self.room_location:
|
|
self.room_location.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.enable_cycle_reservation is not None:
|
|
result['enableCycleReservation'] = self.enable_cycle_reservation
|
|
if self.group_id is not None:
|
|
result['groupId'] = self.group_id
|
|
if self.isv_room_id is not None:
|
|
result['isvRoomId'] = self.isv_room_id
|
|
if self.open_reservation is not None:
|
|
result['openReservation'] = self.open_reservation
|
|
if self.reservation_authority is not None:
|
|
result['reservationAuthority'] = self.reservation_authority.to_map()
|
|
if self.room_capacity is not None:
|
|
result['roomCapacity'] = self.room_capacity
|
|
if self.room_id is not None:
|
|
result['roomId'] = self.room_id
|
|
if self.room_label_ids is not None:
|
|
result['roomLabelIds'] = self.room_label_ids
|
|
if self.room_location is not None:
|
|
result['roomLocation'] = self.room_location.to_map()
|
|
if self.room_name is not None:
|
|
result['roomName'] = self.room_name
|
|
if self.room_picture is not None:
|
|
result['roomPicture'] = self.room_picture
|
|
if self.room_status is not None:
|
|
result['roomStatus'] = self.room_status
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('enableCycleReservation') is not None:
|
|
self.enable_cycle_reservation = m.get('enableCycleReservation')
|
|
if m.get('groupId') is not None:
|
|
self.group_id = m.get('groupId')
|
|
if m.get('isvRoomId') is not None:
|
|
self.isv_room_id = m.get('isvRoomId')
|
|
if m.get('openReservation') is not None:
|
|
self.open_reservation = m.get('openReservation')
|
|
if m.get('reservationAuthority') is not None:
|
|
temp_model = UpdateMeetingRoomRequestReservationAuthority()
|
|
self.reservation_authority = temp_model.from_map(m['reservationAuthority'])
|
|
if m.get('roomCapacity') is not None:
|
|
self.room_capacity = m.get('roomCapacity')
|
|
if m.get('roomId') is not None:
|
|
self.room_id = m.get('roomId')
|
|
if m.get('roomLabelIds') is not None:
|
|
self.room_label_ids = m.get('roomLabelIds')
|
|
if m.get('roomLocation') is not None:
|
|
temp_model = UpdateMeetingRoomRequestRoomLocation()
|
|
self.room_location = temp_model.from_map(m['roomLocation'])
|
|
if m.get('roomName') is not None:
|
|
self.room_name = m.get('roomName')
|
|
if m.get('roomPicture') is not None:
|
|
self.room_picture = m.get('roomPicture')
|
|
if m.get('roomStatus') is not None:
|
|
self.room_status = m.get('roomStatus')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class UpdateMeetingRoomResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: bool = 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 UpdateMeetingRoomResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: UpdateMeetingRoomResponseBody = 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 = UpdateMeetingRoomResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class UpdateMeetingRoomGroupHeaders(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 UpdateMeetingRoomGroupRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
group_id: int = None,
|
|
group_name: str = None,
|
|
union_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.group_id = group_id
|
|
self.group_name = group_name
|
|
# This parameter is required.
|
|
self.union_id = union_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.group_id is not None:
|
|
result['groupId'] = self.group_id
|
|
if self.group_name is not None:
|
|
result['groupName'] = self.group_name
|
|
if self.union_id is not None:
|
|
result['unionId'] = self.union_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('groupId') is not None:
|
|
self.group_id = m.get('groupId')
|
|
if m.get('groupName') is not None:
|
|
self.group_name = m.get('groupName')
|
|
if m.get('unionId') is not None:
|
|
self.union_id = m.get('unionId')
|
|
return self
|
|
|
|
|
|
class UpdateMeetingRoomGroupResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: bool = 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 UpdateMeetingRoomGroupResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: UpdateMeetingRoomGroupResponseBody = 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 = UpdateMeetingRoomGroupResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|