9515 lines
283 KiB
Python
9515 lines
283 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, Any
|
|
|
|
|
|
class HrbrainDeleteAwardRecordsHeaders(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 HrbrainDeleteAwardRecordsRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
award_date: str = None,
|
|
award_name: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.award_date = award_date
|
|
self.award_name = award_name
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.award_date is not None:
|
|
result['awardDate'] = self.award_date
|
|
if self.award_name is not None:
|
|
result['awardName'] = self.award_name
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('awardDate') is not None:
|
|
self.award_date = m.get('awardDate')
|
|
if m.get('awardName') is not None:
|
|
self.award_name = m.get('awardName')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteAwardRecordsRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteAwardRecordsRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteAwardRecordsRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteAwardRecordsResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteAwardRecordsResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteAwardRecordsResponseBody = 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 = HrbrainDeleteAwardRecordsResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteCustomHeaders(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 HrbrainDeleteCustomRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
model_code: str = None,
|
|
params: List[Dict[str, Any]] = None,
|
|
):
|
|
# This parameter is required.
|
|
self.model_code = model_code
|
|
# This parameter is required.
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.model_code is not None:
|
|
result['modelCode'] = self.model_code
|
|
if self.params is not None:
|
|
result['params'] = self.params
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('modelCode') is not None:
|
|
self.model_code = m.get('modelCode')
|
|
if m.get('params') is not None:
|
|
self.params = m.get('params')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteCustomResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteCustomResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteCustomResponseBody = 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 = HrbrainDeleteCustomResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteDeptInfoHeaders(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 HrbrainDeleteDeptInfoRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
dept_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.dept_no = dept_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.dept_no is not None:
|
|
result['deptNo'] = self.dept_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('deptNo') is not None:
|
|
self.dept_no = m.get('deptNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteDeptInfoRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteDeptInfoRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteDeptInfoRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteDeptInfoResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteDeptInfoResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteDeptInfoResponseBody = 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 = HrbrainDeleteDeptInfoResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteDimissionHeaders(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 HrbrainDeleteDimissionRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
dimission_date: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.dimission_date = dimission_date
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.dimission_date is not None:
|
|
result['dimissionDate'] = self.dimission_date
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('dimissionDate') is not None:
|
|
self.dimission_date = m.get('dimissionDate')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteDimissionRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteDimissionRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteDimissionRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteDimissionResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteDimissionResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteDimissionResponseBody = 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 = HrbrainDeleteDimissionResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteEduExpHeaders(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 HrbrainDeleteEduExpRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
edu_name: str = None,
|
|
end_date: str = None,
|
|
school_name: str = None,
|
|
start_date: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.edu_name = edu_name
|
|
self.end_date = end_date
|
|
self.school_name = school_name
|
|
self.start_date = start_date
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.edu_name is not None:
|
|
result['eduName'] = self.edu_name
|
|
if self.end_date is not None:
|
|
result['endDate'] = self.end_date
|
|
if self.school_name is not None:
|
|
result['schoolName'] = self.school_name
|
|
if self.start_date is not None:
|
|
result['startDate'] = self.start_date
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('eduName') is not None:
|
|
self.edu_name = m.get('eduName')
|
|
if m.get('endDate') is not None:
|
|
self.end_date = m.get('endDate')
|
|
if m.get('schoolName') is not None:
|
|
self.school_name = m.get('schoolName')
|
|
if m.get('startDate') is not None:
|
|
self.start_date = m.get('startDate')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteEduExpRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteEduExpRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteEduExpRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteEduExpResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteEduExpResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteEduExpResponseBody = 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 = HrbrainDeleteEduExpResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteEmpInfoHeaders(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 HrbrainDeleteEmpInfoRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
work_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteEmpInfoRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteEmpInfoRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteEmpInfoRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteEmpInfoResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteEmpInfoResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteEmpInfoResponseBody = 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 = HrbrainDeleteEmpInfoResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelIndustryHeaders(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 HrbrainDeleteLabelIndustryRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
label: Dict[str, Any] = None,
|
|
work_no: str = None,
|
|
):
|
|
self.label = label
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.label is not None:
|
|
result['label'] = self.label
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('label') is not None:
|
|
self.label = m.get('label')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelIndustryRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteLabelIndustryRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteLabelIndustryRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelIndustryResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelIndustryResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteLabelIndustryResponseBody = 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 = HrbrainDeleteLabelIndustryResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelInventoryHeaders(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 HrbrainDeleteLabelInventoryRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
label: Dict[str, Any] = None,
|
|
period: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.label = label
|
|
self.period = period
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.label is not None:
|
|
result['label'] = self.label
|
|
if self.period is not None:
|
|
result['period'] = self.period
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('label') is not None:
|
|
self.label = m.get('label')
|
|
if m.get('period') is not None:
|
|
self.period = m.get('period')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelInventoryRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteLabelInventoryRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteLabelInventoryRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelInventoryResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelInventoryResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteLabelInventoryResponseBody = 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 = HrbrainDeleteLabelInventoryResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelProfSkillHeaders(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 HrbrainDeleteLabelProfSkillRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
label: Dict[str, Any] = None,
|
|
work_no: str = None,
|
|
):
|
|
self.label = label
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.label is not None:
|
|
result['label'] = self.label
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('label') is not None:
|
|
self.label = m.get('label')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelProfSkillRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteLabelProfSkillRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteLabelProfSkillRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelProfSkillResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteLabelProfSkillResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteLabelProfSkillResponseBody = 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 = HrbrainDeleteLabelProfSkillResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePerfEvalHeaders(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 HrbrainDeletePerfEvalRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
perf_plan_name: str = None,
|
|
period: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.perf_plan_name = perf_plan_name
|
|
self.period = period
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.perf_plan_name is not None:
|
|
result['perfPlanName'] = self.perf_plan_name
|
|
if self.period is not None:
|
|
result['period'] = self.period
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('perfPlanName') is not None:
|
|
self.perf_plan_name = m.get('perfPlanName')
|
|
if m.get('period') is not None:
|
|
self.period = m.get('period')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePerfEvalRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeletePerfEvalRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeletePerfEvalRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePerfEvalResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePerfEvalResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeletePerfEvalResponseBody = 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 = HrbrainDeletePerfEvalResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePromRecordsHeaders(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 HrbrainDeletePromRecordsRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
award_date: str = None,
|
|
award_name: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.award_date = award_date
|
|
self.award_name = award_name
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.award_date is not None:
|
|
result['awardDate'] = self.award_date
|
|
if self.award_name is not None:
|
|
result['awardName'] = self.award_name
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('awardDate') is not None:
|
|
self.award_date = m.get('awardDate')
|
|
if m.get('awardName') is not None:
|
|
self.award_name = m.get('awardName')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePromRecordsRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeletePromRecordsRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeletePromRecordsRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePromRecordsResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePromRecordsResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeletePromRecordsResponseBody = 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 = HrbrainDeletePromRecordsResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePunDetailHeaders(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 HrbrainDeletePunDetailRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
effective_date: str = None,
|
|
pun_name: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.effective_date = effective_date
|
|
self.pun_name = pun_name
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.effective_date is not None:
|
|
result['effectiveDate'] = self.effective_date
|
|
if self.pun_name is not None:
|
|
result['punName'] = self.pun_name
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('effectiveDate') is not None:
|
|
self.effective_date = m.get('effectiveDate')
|
|
if m.get('punName') is not None:
|
|
self.pun_name = m.get('punName')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePunDetailRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeletePunDetailRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeletePunDetailRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePunDetailResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeletePunDetailResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeletePunDetailResponseBody = 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 = HrbrainDeletePunDetailResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteRegistHeaders(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 HrbrainDeleteRegistRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
regist_date: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.regist_date = regist_date
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.regist_date is not None:
|
|
result['registDate'] = self.regist_date
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('registDate') is not None:
|
|
self.regist_date = m.get('registDate')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteRegistRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteRegistRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteRegistRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteRegistResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteRegistResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteRegistResponseBody = 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 = HrbrainDeleteRegistResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteRegularHeaders(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 HrbrainDeleteRegularRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
regular_date: str = None,
|
|
work_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.regular_date = regular_date
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.regular_date is not None:
|
|
result['regularDate'] = self.regular_date
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('regularDate') is not None:
|
|
self.regular_date = m.get('regularDate')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteRegularRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteRegularRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteRegularRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteRegularResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteRegularResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteRegularResponseBody = 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 = HrbrainDeleteRegularResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteTrainingHeaders(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 HrbrainDeleteTrainingRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
train_end_date: str = None,
|
|
train_name: str = None,
|
|
train_start_date: str = None,
|
|
work_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.train_end_date = train_end_date
|
|
# This parameter is required.
|
|
self.train_name = train_name
|
|
# This parameter is required.
|
|
self.train_start_date = train_start_date
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.train_end_date is not None:
|
|
result['trainEndDate'] = self.train_end_date
|
|
if self.train_name is not None:
|
|
result['trainName'] = self.train_name
|
|
if self.train_start_date is not None:
|
|
result['trainStartDate'] = self.train_start_date
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('trainEndDate') is not None:
|
|
self.train_end_date = m.get('trainEndDate')
|
|
if m.get('trainName') is not None:
|
|
self.train_name = m.get('trainName')
|
|
if m.get('trainStartDate') is not None:
|
|
self.train_start_date = m.get('trainStartDate')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteTrainingRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteTrainingRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteTrainingRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteTrainingResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteTrainingResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteTrainingResponseBody = 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 = HrbrainDeleteTrainingResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteTransferEvalHeaders(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 HrbrainDeleteTransferEvalRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
transfer_date: str = None,
|
|
transfer_type: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.transfer_date = transfer_date
|
|
self.transfer_type = transfer_type
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.transfer_date is not None:
|
|
result['transferDate'] = self.transfer_date
|
|
if self.transfer_type is not None:
|
|
result['transferType'] = self.transfer_type
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('transferDate') is not None:
|
|
self.transfer_date = m.get('transferDate')
|
|
if m.get('transferType') is not None:
|
|
self.transfer_type = m.get('transferType')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteTransferEvalRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteTransferEvalRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteTransferEvalRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteTransferEvalResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteTransferEvalResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteTransferEvalResponseBody = 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 = HrbrainDeleteTransferEvalResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteWorkExpHeaders(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 HrbrainDeleteWorkExpRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
company_name: str = None,
|
|
end_date: str = None,
|
|
start_date: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.company_name = company_name
|
|
self.end_date = end_date
|
|
self.start_date = start_date
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.company_name is not None:
|
|
result['companyName'] = self.company_name
|
|
if self.end_date is not None:
|
|
result['endDate'] = self.end_date
|
|
if self.start_date is not None:
|
|
result['startDate'] = self.start_date
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('companyName') is not None:
|
|
self.company_name = m.get('companyName')
|
|
if m.get('endDate') is not None:
|
|
self.end_date = m.get('endDate')
|
|
if m.get('startDate') is not None:
|
|
self.start_date = m.get('startDate')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteWorkExpRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeleteWorkExpRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeleteWorkExpRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteWorkExpResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeleteWorkExpResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeleteWorkExpResponseBody = 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 = HrbrainDeleteWorkExpResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainDeletetLabelBaseHeaders(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 HrbrainDeletetLabelBaseRequestParams(TeaModel):
|
|
def __init__(
|
|
self,
|
|
label: Dict[str, Any] = None,
|
|
work_no: str = None,
|
|
):
|
|
self.label = label
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.label is not None:
|
|
result['label'] = self.label
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('label') is not None:
|
|
self.label = m.get('label')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainDeletetLabelBaseRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
params: List[HrbrainDeletetLabelBaseRequestParams] = None,
|
|
):
|
|
self.params = params
|
|
|
|
def validate(self):
|
|
if self.params:
|
|
for k in self.params:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['params'] = []
|
|
if self.params is not None:
|
|
for k in self.params:
|
|
result['params'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.params = []
|
|
if m.get('params') is not None:
|
|
for k in m.get('params'):
|
|
temp_model = HrbrainDeletetLabelBaseRequestParams()
|
|
self.params.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainDeletetLabelBaseResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainDeletetLabelBaseResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainDeletetLabelBaseResponseBody = 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 = HrbrainDeletetLabelBaseResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainEmpPoolQueryHeaders(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 HrbrainEmpPoolQueryRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
keyword: str = None,
|
|
labels: List[str] = None,
|
|
max_results: int = None,
|
|
next_token: int = None,
|
|
):
|
|
self.keyword = keyword
|
|
self.labels = labels
|
|
self.max_results = max_results
|
|
self.next_token = next_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.keyword is not None:
|
|
result['keyword'] = self.keyword
|
|
if self.labels is not None:
|
|
result['labels'] = self.labels
|
|
if self.max_results is not None:
|
|
result['maxResults'] = self.max_results
|
|
if self.next_token is not None:
|
|
result['nextToken'] = self.next_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('keyword') is not None:
|
|
self.keyword = m.get('keyword')
|
|
if m.get('labels') is not None:
|
|
self.labels = m.get('labels')
|
|
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')
|
|
return self
|
|
|
|
|
|
class HrbrainEmpPoolQueryResponseBodyContentPoolInfosPoolTags(TeaModel):
|
|
def __init__(
|
|
self,
|
|
label: str = None,
|
|
value: str = None,
|
|
):
|
|
self.label = label
|
|
self.value = value
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.label is not None:
|
|
result['label'] = self.label
|
|
if self.value is not None:
|
|
result['value'] = self.value
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('label') is not None:
|
|
self.label = m.get('label')
|
|
if m.get('value') is not None:
|
|
self.value = m.get('value')
|
|
return self
|
|
|
|
|
|
class HrbrainEmpPoolQueryResponseBodyContentPoolInfos(TeaModel):
|
|
def __init__(
|
|
self,
|
|
pool_code: str = None,
|
|
pool_desc: str = None,
|
|
pool_name: str = None,
|
|
pool_tags: List[HrbrainEmpPoolQueryResponseBodyContentPoolInfosPoolTags] = None,
|
|
):
|
|
self.pool_code = pool_code
|
|
self.pool_desc = pool_desc
|
|
self.pool_name = pool_name
|
|
self.pool_tags = pool_tags
|
|
|
|
def validate(self):
|
|
if self.pool_tags:
|
|
for k in self.pool_tags:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.pool_code is not None:
|
|
result['poolCode'] = self.pool_code
|
|
if self.pool_desc is not None:
|
|
result['poolDesc'] = self.pool_desc
|
|
if self.pool_name is not None:
|
|
result['poolName'] = self.pool_name
|
|
result['poolTags'] = []
|
|
if self.pool_tags is not None:
|
|
for k in self.pool_tags:
|
|
result['poolTags'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('poolCode') is not None:
|
|
self.pool_code = m.get('poolCode')
|
|
if m.get('poolDesc') is not None:
|
|
self.pool_desc = m.get('poolDesc')
|
|
if m.get('poolName') is not None:
|
|
self.pool_name = m.get('poolName')
|
|
self.pool_tags = []
|
|
if m.get('poolTags') is not None:
|
|
for k in m.get('poolTags'):
|
|
temp_model = HrbrainEmpPoolQueryResponseBodyContentPoolInfosPoolTags()
|
|
self.pool_tags.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainEmpPoolQueryResponseBodyContent(TeaModel):
|
|
def __init__(
|
|
self,
|
|
max_results: int = None,
|
|
next_token: int = None,
|
|
pool_infos: List[HrbrainEmpPoolQueryResponseBodyContentPoolInfos] = None,
|
|
total_count: int = None,
|
|
):
|
|
self.max_results = max_results
|
|
self.next_token = next_token
|
|
self.pool_infos = pool_infos
|
|
self.total_count = total_count
|
|
|
|
def validate(self):
|
|
if self.pool_infos:
|
|
for k in self.pool_infos:
|
|
if k:
|
|
k.validate()
|
|
|
|
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
|
|
result['poolInfos'] = []
|
|
if self.pool_infos is not None:
|
|
for k in self.pool_infos:
|
|
result['poolInfos'].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('maxResults') is not None:
|
|
self.max_results = m.get('maxResults')
|
|
if m.get('nextToken') is not None:
|
|
self.next_token = m.get('nextToken')
|
|
self.pool_infos = []
|
|
if m.get('poolInfos') is not None:
|
|
for k in m.get('poolInfos'):
|
|
temp_model = HrbrainEmpPoolQueryResponseBodyContentPoolInfos()
|
|
self.pool_infos.append(temp_model.from_map(k))
|
|
if m.get('totalCount') is not None:
|
|
self.total_count = m.get('totalCount')
|
|
return self
|
|
|
|
|
|
class HrbrainEmpPoolQueryResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
content: HrbrainEmpPoolQueryResponseBodyContent = None,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.content = content
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
if self.content:
|
|
self.content.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.content is not None:
|
|
result['content'] = self.content.to_map()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('content') is not None:
|
|
temp_model = HrbrainEmpPoolQueryResponseBodyContent()
|
|
self.content = temp_model.from_map(m['content'])
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainEmpPoolQueryResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainEmpPoolQueryResponseBody = 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 = HrbrainEmpPoolQueryResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainEmpPoolUserHeaders(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 HrbrainEmpPoolUserRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
max_results: int = None,
|
|
next_token: int = None,
|
|
pool_code: str = None,
|
|
):
|
|
self.max_results = max_results
|
|
self.next_token = next_token
|
|
self.pool_code = pool_code
|
|
|
|
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.pool_code is not None:
|
|
result['poolCode'] = self.pool_code
|
|
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('poolCode') is not None:
|
|
self.pool_code = m.get('poolCode')
|
|
return self
|
|
|
|
|
|
class HrbrainEmpPoolUserResponseBodyContentEmpVos(TeaModel):
|
|
def __init__(
|
|
self,
|
|
name: str = None,
|
|
user_id: str = None,
|
|
):
|
|
self.name = name
|
|
self.user_id = user_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.user_id is not None:
|
|
result['userId'] = self.user_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('userId') is not None:
|
|
self.user_id = m.get('userId')
|
|
return self
|
|
|
|
|
|
class HrbrainEmpPoolUserResponseBodyContent(TeaModel):
|
|
def __init__(
|
|
self,
|
|
emp_vos: List[HrbrainEmpPoolUserResponseBodyContentEmpVos] = None,
|
|
max_results: int = None,
|
|
next_token: int = None,
|
|
total_count: int = None,
|
|
):
|
|
self.emp_vos = emp_vos
|
|
self.max_results = max_results
|
|
self.next_token = next_token
|
|
self.total_count = total_count
|
|
|
|
def validate(self):
|
|
if self.emp_vos:
|
|
for k in self.emp_vos:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['empVos'] = []
|
|
if self.emp_vos is not None:
|
|
for k in self.emp_vos:
|
|
result['empVos'].append(k.to_map() if k else None)
|
|
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.total_count is not None:
|
|
result['totalCount'] = self.total_count
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.emp_vos = []
|
|
if m.get('empVos') is not None:
|
|
for k in m.get('empVos'):
|
|
temp_model = HrbrainEmpPoolUserResponseBodyContentEmpVos()
|
|
self.emp_vos.append(temp_model.from_map(k))
|
|
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('totalCount') is not None:
|
|
self.total_count = m.get('totalCount')
|
|
return self
|
|
|
|
|
|
class HrbrainEmpPoolUserResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
content: HrbrainEmpPoolUserResponseBodyContent = None,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.content = content
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
if self.content:
|
|
self.content.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.content is not None:
|
|
result['content'] = self.content.to_map()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('content') is not None:
|
|
temp_model = HrbrainEmpPoolUserResponseBodyContent()
|
|
self.content = temp_model.from_map(m['content'])
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainEmpPoolUserResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainEmpPoolUserResponseBody = 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 = HrbrainEmpPoolUserResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportAwardDetailHeaders(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 HrbrainImportAwardDetailRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
award_date: str = None,
|
|
award_name: str = None,
|
|
award_org: str = None,
|
|
award_type: str = None,
|
|
comment: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
name: str = None,
|
|
work_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.award_date = award_date
|
|
# This parameter is required.
|
|
self.award_name = award_name
|
|
self.award_org = award_org
|
|
self.award_type = award_type
|
|
self.comment = comment
|
|
self.extend_info = extend_info
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.award_date is not None:
|
|
result['awardDate'] = self.award_date
|
|
if self.award_name is not None:
|
|
result['awardName'] = self.award_name
|
|
if self.award_org is not None:
|
|
result['awardOrg'] = self.award_org
|
|
if self.award_type is not None:
|
|
result['awardType'] = self.award_type
|
|
if self.comment is not None:
|
|
result['comment'] = self.comment
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('awardDate') is not None:
|
|
self.award_date = m.get('awardDate')
|
|
if m.get('awardName') is not None:
|
|
self.award_name = m.get('awardName')
|
|
if m.get('awardOrg') is not None:
|
|
self.award_org = m.get('awardOrg')
|
|
if m.get('awardType') is not None:
|
|
self.award_type = m.get('awardType')
|
|
if m.get('comment') is not None:
|
|
self.comment = m.get('comment')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportAwardDetailRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportAwardDetailRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportAwardDetailRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportAwardDetailResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportAwardDetailResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportAwardDetailResponseBody = 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 = HrbrainImportAwardDetailResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportCustomHeaders(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 HrbrainImportCustomRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[Dict[str, Any]] = None,
|
|
corp_id: str = None,
|
|
model_code: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
# This parameter is required.
|
|
self.model_code = model_code
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.body is not None:
|
|
result['body'] = self.body
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
if self.model_code is not None:
|
|
result['modelCode'] = self.model_code
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('body') is not None:
|
|
self.body = m.get('body')
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
if m.get('modelCode') is not None:
|
|
self.model_code = m.get('modelCode')
|
|
return self
|
|
|
|
|
|
class HrbrainImportCustomResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportCustomResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportCustomResponseBody = 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 = HrbrainImportCustomResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportDeptInfoHeaders(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 HrbrainImportDeptInfoRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
create_date: str = None,
|
|
dept_name: str = None,
|
|
dept_no: str = None,
|
|
effective_date: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
is_effective: str = None,
|
|
super_dept_name: str = None,
|
|
super_dept_no: str = None,
|
|
super_emp_id: str = None,
|
|
super_name: str = None,
|
|
):
|
|
self.create_date = create_date
|
|
# This parameter is required.
|
|
self.dept_name = dept_name
|
|
# This parameter is required.
|
|
self.dept_no = dept_no
|
|
self.effective_date = effective_date
|
|
self.extend_info = extend_info
|
|
self.is_effective = is_effective
|
|
self.super_dept_name = super_dept_name
|
|
# This parameter is required.
|
|
self.super_dept_no = super_dept_no
|
|
self.super_emp_id = super_emp_id
|
|
self.super_name = super_name
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.create_date is not None:
|
|
result['createDate'] = self.create_date
|
|
if self.dept_name is not None:
|
|
result['deptName'] = self.dept_name
|
|
if self.dept_no is not None:
|
|
result['deptNo'] = self.dept_no
|
|
if self.effective_date is not None:
|
|
result['effectiveDate'] = self.effective_date
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.is_effective is not None:
|
|
result['isEffective'] = self.is_effective
|
|
if self.super_dept_name is not None:
|
|
result['superDeptName'] = self.super_dept_name
|
|
if self.super_dept_no is not None:
|
|
result['superDeptNo'] = self.super_dept_no
|
|
if self.super_emp_id is not None:
|
|
result['superEmpId'] = self.super_emp_id
|
|
if self.super_name is not None:
|
|
result['superName'] = self.super_name
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('createDate') is not None:
|
|
self.create_date = m.get('createDate')
|
|
if m.get('deptName') is not None:
|
|
self.dept_name = m.get('deptName')
|
|
if m.get('deptNo') is not None:
|
|
self.dept_no = m.get('deptNo')
|
|
if m.get('effectiveDate') is not None:
|
|
self.effective_date = m.get('effectiveDate')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('isEffective') is not None:
|
|
self.is_effective = m.get('isEffective')
|
|
if m.get('superDeptName') is not None:
|
|
self.super_dept_name = m.get('superDeptName')
|
|
if m.get('superDeptNo') is not None:
|
|
self.super_dept_no = m.get('superDeptNo')
|
|
if m.get('superEmpId') is not None:
|
|
self.super_emp_id = m.get('superEmpId')
|
|
if m.get('superName') is not None:
|
|
self.super_name = m.get('superName')
|
|
return self
|
|
|
|
|
|
class HrbrainImportDeptInfoRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportDeptInfoRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportDeptInfoRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportDeptInfoResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportDeptInfoResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportDeptInfoResponseBody = 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 = HrbrainImportDeptInfoResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportDimissionHeaders(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 HrbrainImportDimissionRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
dept_name: str = None,
|
|
dept_no: str = None,
|
|
dimission_date: str = None,
|
|
dimission_reaason_desc: str = None,
|
|
dimission_reason: str = None,
|
|
emp_type: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
job_code_name: str = None,
|
|
job_level: str = None,
|
|
name: str = None,
|
|
post_name: str = None,
|
|
super_name: str = None,
|
|
work_loc_addr: str = None,
|
|
work_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.dept_name = dept_name
|
|
# This parameter is required.
|
|
self.dept_no = dept_no
|
|
# This parameter is required.
|
|
self.dimission_date = dimission_date
|
|
# This parameter is required.
|
|
self.dimission_reaason_desc = dimission_reaason_desc
|
|
# This parameter is required.
|
|
self.dimission_reason = dimission_reason
|
|
# This parameter is required.
|
|
self.emp_type = emp_type
|
|
self.extend_info = extend_info
|
|
self.job_code_name = job_code_name
|
|
self.job_level = job_level
|
|
# This parameter is required.
|
|
self.name = name
|
|
self.post_name = post_name
|
|
# This parameter is required.
|
|
self.super_name = super_name
|
|
self.work_loc_addr = work_loc_addr
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.dept_name is not None:
|
|
result['deptName'] = self.dept_name
|
|
if self.dept_no is not None:
|
|
result['deptNo'] = self.dept_no
|
|
if self.dimission_date is not None:
|
|
result['dimissionDate'] = self.dimission_date
|
|
if self.dimission_reaason_desc is not None:
|
|
result['dimissionReaasonDesc'] = self.dimission_reaason_desc
|
|
if self.dimission_reason is not None:
|
|
result['dimissionReason'] = self.dimission_reason
|
|
if self.emp_type is not None:
|
|
result['empType'] = self.emp_type
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.job_code_name is not None:
|
|
result['jobCodeName'] = self.job_code_name
|
|
if self.job_level is not None:
|
|
result['jobLevel'] = self.job_level
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.post_name is not None:
|
|
result['postName'] = self.post_name
|
|
if self.super_name is not None:
|
|
result['superName'] = self.super_name
|
|
if self.work_loc_addr is not None:
|
|
result['workLocAddr'] = self.work_loc_addr
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('deptName') is not None:
|
|
self.dept_name = m.get('deptName')
|
|
if m.get('deptNo') is not None:
|
|
self.dept_no = m.get('deptNo')
|
|
if m.get('dimissionDate') is not None:
|
|
self.dimission_date = m.get('dimissionDate')
|
|
if m.get('dimissionReaasonDesc') is not None:
|
|
self.dimission_reaason_desc = m.get('dimissionReaasonDesc')
|
|
if m.get('dimissionReason') is not None:
|
|
self.dimission_reason = m.get('dimissionReason')
|
|
if m.get('empType') is not None:
|
|
self.emp_type = m.get('empType')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('jobCodeName') is not None:
|
|
self.job_code_name = m.get('jobCodeName')
|
|
if m.get('jobLevel') is not None:
|
|
self.job_level = m.get('jobLevel')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('postName') is not None:
|
|
self.post_name = m.get('postName')
|
|
if m.get('superName') is not None:
|
|
self.super_name = m.get('superName')
|
|
if m.get('workLocAddr') is not None:
|
|
self.work_loc_addr = m.get('workLocAddr')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportDimissionRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportDimissionRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportDimissionRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportDimissionResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportDimissionResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportDimissionResponseBody = 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 = HrbrainImportDimissionResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportEduExpHeaders(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 HrbrainImportEduExpRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
edu_name: str = None,
|
|
end_date: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
major: str = None,
|
|
name: str = None,
|
|
school_name: str = None,
|
|
start_date: str = None,
|
|
work_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.edu_name = edu_name
|
|
# This parameter is required.
|
|
self.end_date = end_date
|
|
self.extend_info = extend_info
|
|
self.major = major
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.school_name = school_name
|
|
# This parameter is required.
|
|
self.start_date = start_date
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.edu_name is not None:
|
|
result['eduName'] = self.edu_name
|
|
if self.end_date is not None:
|
|
result['endDate'] = self.end_date
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.major is not None:
|
|
result['major'] = self.major
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.school_name is not None:
|
|
result['schoolName'] = self.school_name
|
|
if self.start_date is not None:
|
|
result['startDate'] = self.start_date
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('eduName') is not None:
|
|
self.edu_name = m.get('eduName')
|
|
if m.get('endDate') is not None:
|
|
self.end_date = m.get('endDate')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('major') is not None:
|
|
self.major = m.get('major')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('schoolName') is not None:
|
|
self.school_name = m.get('schoolName')
|
|
if m.get('startDate') is not None:
|
|
self.start_date = m.get('startDate')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportEduExpRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportEduExpRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportEduExpRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportEduExpResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportEduExpResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportEduExpResponseBody = 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 = HrbrainImportEduExpResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportEmpInfoHeaders(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 HrbrainImportEmpInfoRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
birthday: str = None,
|
|
dept_name: str = None,
|
|
dept_no: str = None,
|
|
dimission_date: str = None,
|
|
emp_source: str = None,
|
|
emp_status: str = None,
|
|
emp_type: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
gender: str = None,
|
|
highest_degree: str = None,
|
|
highest_edu_name: str = None,
|
|
is_dimission: str = None,
|
|
job_code_name: str = None,
|
|
job_level: str = None,
|
|
last_school_name: str = None,
|
|
marriage: str = None,
|
|
name: str = None,
|
|
nation: str = None,
|
|
nation_ctry: str = None,
|
|
political_status: str = None,
|
|
post_name: str = None,
|
|
regist_date: str = None,
|
|
regular_date: str = None,
|
|
super_emp_id: str = None,
|
|
super_name: str = None,
|
|
work_email: str = None,
|
|
work_loc_addr: str = None,
|
|
work_loc_city: str = None,
|
|
work_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.birthday = birthday
|
|
# This parameter is required.
|
|
self.dept_name = dept_name
|
|
# This parameter is required.
|
|
self.dept_no = dept_no
|
|
self.dimission_date = dimission_date
|
|
# This parameter is required.
|
|
self.emp_source = emp_source
|
|
# This parameter is required.
|
|
self.emp_status = emp_status
|
|
# This parameter is required.
|
|
self.emp_type = emp_type
|
|
self.extend_info = extend_info
|
|
# This parameter is required.
|
|
self.gender = gender
|
|
self.highest_degree = highest_degree
|
|
self.highest_edu_name = highest_edu_name
|
|
self.is_dimission = is_dimission
|
|
# This parameter is required.
|
|
self.job_code_name = job_code_name
|
|
self.job_level = job_level
|
|
self.last_school_name = last_school_name
|
|
self.marriage = marriage
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.nation = nation
|
|
# This parameter is required.
|
|
self.nation_ctry = nation_ctry
|
|
# This parameter is required.
|
|
self.political_status = political_status
|
|
# This parameter is required.
|
|
self.post_name = post_name
|
|
self.regist_date = regist_date
|
|
self.regular_date = regular_date
|
|
self.super_emp_id = super_emp_id
|
|
self.super_name = super_name
|
|
self.work_email = work_email
|
|
self.work_loc_addr = work_loc_addr
|
|
self.work_loc_city = work_loc_city
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.birthday is not None:
|
|
result['birthday'] = self.birthday
|
|
if self.dept_name is not None:
|
|
result['deptName'] = self.dept_name
|
|
if self.dept_no is not None:
|
|
result['deptNo'] = self.dept_no
|
|
if self.dimission_date is not None:
|
|
result['dimissionDate'] = self.dimission_date
|
|
if self.emp_source is not None:
|
|
result['empSource'] = self.emp_source
|
|
if self.emp_status is not None:
|
|
result['empStatus'] = self.emp_status
|
|
if self.emp_type is not None:
|
|
result['empType'] = self.emp_type
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.gender is not None:
|
|
result['gender'] = self.gender
|
|
if self.highest_degree is not None:
|
|
result['highestDegree'] = self.highest_degree
|
|
if self.highest_edu_name is not None:
|
|
result['highestEduName'] = self.highest_edu_name
|
|
if self.is_dimission is not None:
|
|
result['isDimission'] = self.is_dimission
|
|
if self.job_code_name is not None:
|
|
result['jobCodeName'] = self.job_code_name
|
|
if self.job_level is not None:
|
|
result['jobLevel'] = self.job_level
|
|
if self.last_school_name is not None:
|
|
result['lastSchoolName'] = self.last_school_name
|
|
if self.marriage is not None:
|
|
result['marriage'] = self.marriage
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.nation is not None:
|
|
result['nation'] = self.nation
|
|
if self.nation_ctry is not None:
|
|
result['nationCtry'] = self.nation_ctry
|
|
if self.political_status is not None:
|
|
result['politicalStatus'] = self.political_status
|
|
if self.post_name is not None:
|
|
result['postName'] = self.post_name
|
|
if self.regist_date is not None:
|
|
result['registDate'] = self.regist_date
|
|
if self.regular_date is not None:
|
|
result['regularDate'] = self.regular_date
|
|
if self.super_emp_id is not None:
|
|
result['superEmpId'] = self.super_emp_id
|
|
if self.super_name is not None:
|
|
result['superName'] = self.super_name
|
|
if self.work_email is not None:
|
|
result['workEmail'] = self.work_email
|
|
if self.work_loc_addr is not None:
|
|
result['workLocAddr'] = self.work_loc_addr
|
|
if self.work_loc_city is not None:
|
|
result['workLocCity'] = self.work_loc_city
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('birthday') is not None:
|
|
self.birthday = m.get('birthday')
|
|
if m.get('deptName') is not None:
|
|
self.dept_name = m.get('deptName')
|
|
if m.get('deptNo') is not None:
|
|
self.dept_no = m.get('deptNo')
|
|
if m.get('dimissionDate') is not None:
|
|
self.dimission_date = m.get('dimissionDate')
|
|
if m.get('empSource') is not None:
|
|
self.emp_source = m.get('empSource')
|
|
if m.get('empStatus') is not None:
|
|
self.emp_status = m.get('empStatus')
|
|
if m.get('empType') is not None:
|
|
self.emp_type = m.get('empType')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('gender') is not None:
|
|
self.gender = m.get('gender')
|
|
if m.get('highestDegree') is not None:
|
|
self.highest_degree = m.get('highestDegree')
|
|
if m.get('highestEduName') is not None:
|
|
self.highest_edu_name = m.get('highestEduName')
|
|
if m.get('isDimission') is not None:
|
|
self.is_dimission = m.get('isDimission')
|
|
if m.get('jobCodeName') is not None:
|
|
self.job_code_name = m.get('jobCodeName')
|
|
if m.get('jobLevel') is not None:
|
|
self.job_level = m.get('jobLevel')
|
|
if m.get('lastSchoolName') is not None:
|
|
self.last_school_name = m.get('lastSchoolName')
|
|
if m.get('marriage') is not None:
|
|
self.marriage = m.get('marriage')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('nation') is not None:
|
|
self.nation = m.get('nation')
|
|
if m.get('nationCtry') is not None:
|
|
self.nation_ctry = m.get('nationCtry')
|
|
if m.get('politicalStatus') is not None:
|
|
self.political_status = m.get('politicalStatus')
|
|
if m.get('postName') is not None:
|
|
self.post_name = m.get('postName')
|
|
if m.get('registDate') is not None:
|
|
self.regist_date = m.get('registDate')
|
|
if m.get('regularDate') is not None:
|
|
self.regular_date = m.get('regularDate')
|
|
if m.get('superEmpId') is not None:
|
|
self.super_emp_id = m.get('superEmpId')
|
|
if m.get('superName') is not None:
|
|
self.super_name = m.get('superName')
|
|
if m.get('workEmail') is not None:
|
|
self.work_email = m.get('workEmail')
|
|
if m.get('workLocAddr') is not None:
|
|
self.work_loc_addr = m.get('workLocAddr')
|
|
if m.get('workLocCity') is not None:
|
|
self.work_loc_city = m.get('workLocCity')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportEmpInfoRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportEmpInfoRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportEmpInfoRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportEmpInfoResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportEmpInfoResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportEmpInfoResponseBody = 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 = HrbrainImportEmpInfoResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelBaseHeaders(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 HrbrainImportLabelBaseRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
extend_info: Dict[str, Any] = None,
|
|
name: str = None,
|
|
work_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.extend_info = extend_info
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelBaseRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportLabelBaseRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportLabelBaseRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelBaseResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelBaseResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportLabelBaseResponseBody = 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 = HrbrainImportLabelBaseResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelCustomHeaders(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 HrbrainImportLabelCustomRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
extend_info: Dict[str, Any] = None,
|
|
name: str = None,
|
|
tag: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.extend_info = extend_info
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.tag = tag
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.tag is not None:
|
|
result['tag'] = self.tag
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('tag') is not None:
|
|
self.tag = m.get('tag')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelCustomRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportLabelCustomRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportLabelCustomRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelCustomResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelCustomResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportLabelCustomResponseBody = 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 = HrbrainImportLabelCustomResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelIndustryHeaders(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 HrbrainImportLabelIndustryRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
extend_info: Dict[str, Any] = None,
|
|
level_1: str = None,
|
|
level_2: str = None,
|
|
level_3: str = None,
|
|
name: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.extend_info = extend_info
|
|
# This parameter is required.
|
|
self.level_1 = level_1
|
|
# This parameter is required.
|
|
self.level_2 = level_2
|
|
# This parameter is required.
|
|
self.level_3 = level_3
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.level_1 is not None:
|
|
result['level1'] = self.level_1
|
|
if self.level_2 is not None:
|
|
result['level2'] = self.level_2
|
|
if self.level_3 is not None:
|
|
result['level3'] = self.level_3
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('level1') is not None:
|
|
self.level_1 = m.get('level1')
|
|
if m.get('level2') is not None:
|
|
self.level_2 = m.get('level2')
|
|
if m.get('level3') is not None:
|
|
self.level_3 = m.get('level3')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelIndustryRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportLabelIndustryRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportLabelIndustryRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelIndustryResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelIndustryResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportLabelIndustryResponseBody = 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 = HrbrainImportLabelIndustryResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelInventoryHeaders(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 HrbrainImportLabelInventoryRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
extend_info: Dict[str, Any] = None,
|
|
name: str = None,
|
|
period: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.extend_info = extend_info
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.period = period
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.period is not None:
|
|
result['period'] = self.period
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('period') is not None:
|
|
self.period = m.get('period')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelInventoryRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportLabelInventoryRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportLabelInventoryRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelInventoryResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelInventoryResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportLabelInventoryResponseBody = 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 = HrbrainImportLabelInventoryResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelProfSkillHeaders(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 HrbrainImportLabelProfSkillRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
extend_info: Dict[str, Any] = None,
|
|
level_1: str = None,
|
|
level_2: str = None,
|
|
level_3: str = None,
|
|
name: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.extend_info = extend_info
|
|
# This parameter is required.
|
|
self.level_1 = level_1
|
|
# This parameter is required.
|
|
self.level_2 = level_2
|
|
# This parameter is required.
|
|
self.level_3 = level_3
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.level_1 is not None:
|
|
result['level1'] = self.level_1
|
|
if self.level_2 is not None:
|
|
result['level2'] = self.level_2
|
|
if self.level_3 is not None:
|
|
result['level3'] = self.level_3
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('level1') is not None:
|
|
self.level_1 = m.get('level1')
|
|
if m.get('level2') is not None:
|
|
self.level_2 = m.get('level2')
|
|
if m.get('level3') is not None:
|
|
self.level_3 = m.get('level3')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelProfSkillRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportLabelProfSkillRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportLabelProfSkillRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelProfSkillResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportLabelProfSkillResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportLabelProfSkillResponseBody = 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 = HrbrainImportLabelProfSkillResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportPerfEvalHeaders(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 HrbrainImportPerfEvalRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
comment: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
name: str = None,
|
|
perf_cate: str = None,
|
|
perf_plan_name: str = None,
|
|
perf_score: str = None,
|
|
period: str = None,
|
|
period_end_date: str = None,
|
|
period_start_date: str = None,
|
|
score: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.comment = comment
|
|
self.extend_info = extend_info
|
|
# This parameter is required.
|
|
self.name = name
|
|
self.perf_cate = perf_cate
|
|
# This parameter is required.
|
|
self.perf_plan_name = perf_plan_name
|
|
self.perf_score = perf_score
|
|
# This parameter is required.
|
|
self.period = period
|
|
# This parameter is required.
|
|
self.period_end_date = period_end_date
|
|
# This parameter is required.
|
|
self.period_start_date = period_start_date
|
|
# This parameter is required.
|
|
self.score = score
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.comment is not None:
|
|
result['comment'] = self.comment
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.perf_cate is not None:
|
|
result['perfCate'] = self.perf_cate
|
|
if self.perf_plan_name is not None:
|
|
result['perfPlanName'] = self.perf_plan_name
|
|
if self.perf_score is not None:
|
|
result['perfScore'] = self.perf_score
|
|
if self.period is not None:
|
|
result['period'] = self.period
|
|
if self.period_end_date is not None:
|
|
result['periodEndDate'] = self.period_end_date
|
|
if self.period_start_date is not None:
|
|
result['periodStartDate'] = self.period_start_date
|
|
if self.score is not None:
|
|
result['score'] = self.score
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('comment') is not None:
|
|
self.comment = m.get('comment')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('perfCate') is not None:
|
|
self.perf_cate = m.get('perfCate')
|
|
if m.get('perfPlanName') is not None:
|
|
self.perf_plan_name = m.get('perfPlanName')
|
|
if m.get('perfScore') is not None:
|
|
self.perf_score = m.get('perfScore')
|
|
if m.get('period') is not None:
|
|
self.period = m.get('period')
|
|
if m.get('periodEndDate') is not None:
|
|
self.period_end_date = m.get('periodEndDate')
|
|
if m.get('periodStartDate') is not None:
|
|
self.period_start_date = m.get('periodStartDate')
|
|
if m.get('score') is not None:
|
|
self.score = m.get('score')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportPerfEvalRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportPerfEvalRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportPerfEvalRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportPerfEvalResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportPerfEvalResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportPerfEvalResponseBody = 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 = HrbrainImportPerfEvalResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportPromEvalHeaders(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 HrbrainImportPromEvalRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
comment: str = None,
|
|
effective_date: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
name: str = None,
|
|
new_job_level: str = None,
|
|
period: str = None,
|
|
period_end_date: str = None,
|
|
period_start_date: str = None,
|
|
pre_job_level: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.comment = comment
|
|
# This parameter is required.
|
|
self.effective_date = effective_date
|
|
self.extend_info = extend_info
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.new_job_level = new_job_level
|
|
# This parameter is required.
|
|
self.period = period
|
|
self.period_end_date = period_end_date
|
|
self.period_start_date = period_start_date
|
|
# This parameter is required.
|
|
self.pre_job_level = pre_job_level
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.comment is not None:
|
|
result['comment'] = self.comment
|
|
if self.effective_date is not None:
|
|
result['effectiveDate'] = self.effective_date
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.new_job_level is not None:
|
|
result['newJobLevel'] = self.new_job_level
|
|
if self.period is not None:
|
|
result['period'] = self.period
|
|
if self.period_end_date is not None:
|
|
result['periodEndDate'] = self.period_end_date
|
|
if self.period_start_date is not None:
|
|
result['periodStartDate'] = self.period_start_date
|
|
if self.pre_job_level is not None:
|
|
result['preJobLevel'] = self.pre_job_level
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('comment') is not None:
|
|
self.comment = m.get('comment')
|
|
if m.get('effectiveDate') is not None:
|
|
self.effective_date = m.get('effectiveDate')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('newJobLevel') is not None:
|
|
self.new_job_level = m.get('newJobLevel')
|
|
if m.get('period') is not None:
|
|
self.period = m.get('period')
|
|
if m.get('periodEndDate') is not None:
|
|
self.period_end_date = m.get('periodEndDate')
|
|
if m.get('periodStartDate') is not None:
|
|
self.period_start_date = m.get('periodStartDate')
|
|
if m.get('preJobLevel') is not None:
|
|
self.pre_job_level = m.get('preJobLevel')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportPromEvalRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportPromEvalRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportPromEvalRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportPromEvalResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportPromEvalResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportPromEvalResponseBody = 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 = HrbrainImportPromEvalResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportPunDetailHeaders(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 HrbrainImportPunDetailRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
comment: str = None,
|
|
effective_date: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
name: str = None,
|
|
pun_name: str = None,
|
|
pun_org: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.comment = comment
|
|
# This parameter is required.
|
|
self.effective_date = effective_date
|
|
self.extend_info = extend_info
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.pun_name = pun_name
|
|
self.pun_org = pun_org
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.comment is not None:
|
|
result['comment'] = self.comment
|
|
if self.effective_date is not None:
|
|
result['effectiveDate'] = self.effective_date
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.pun_name is not None:
|
|
result['punName'] = self.pun_name
|
|
if self.pun_org is not None:
|
|
result['punOrg'] = self.pun_org
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('comment') is not None:
|
|
self.comment = m.get('comment')
|
|
if m.get('effectiveDate') is not None:
|
|
self.effective_date = m.get('effectiveDate')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('punName') is not None:
|
|
self.pun_name = m.get('punName')
|
|
if m.get('punOrg') is not None:
|
|
self.pun_org = m.get('punOrg')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportPunDetailRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportPunDetailRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportPunDetailRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportPunDetailResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportPunDetailResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportPunDetailResponseBody = 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 = HrbrainImportPunDetailResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportRegistHeaders(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 HrbrainImportRegistRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
dept_name: str = None,
|
|
dept_no: str = None,
|
|
emp_source: str = None,
|
|
emp_type: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
job_code_name: str = None,
|
|
job_level: str = None,
|
|
name: str = None,
|
|
post_name: str = None,
|
|
regist_date: str = None,
|
|
super_name: str = None,
|
|
work_loc_addr: str = None,
|
|
work_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.dept_name = dept_name
|
|
# This parameter is required.
|
|
self.dept_no = dept_no
|
|
# This parameter is required.
|
|
self.emp_source = emp_source
|
|
# This parameter is required.
|
|
self.emp_type = emp_type
|
|
self.extend_info = extend_info
|
|
self.job_code_name = job_code_name
|
|
self.job_level = job_level
|
|
# This parameter is required.
|
|
self.name = name
|
|
self.post_name = post_name
|
|
# This parameter is required.
|
|
self.regist_date = regist_date
|
|
self.super_name = super_name
|
|
self.work_loc_addr = work_loc_addr
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.dept_name is not None:
|
|
result['deptName'] = self.dept_name
|
|
if self.dept_no is not None:
|
|
result['deptNo'] = self.dept_no
|
|
if self.emp_source is not None:
|
|
result['empSource'] = self.emp_source
|
|
if self.emp_type is not None:
|
|
result['empType'] = self.emp_type
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.job_code_name is not None:
|
|
result['jobCodeName'] = self.job_code_name
|
|
if self.job_level is not None:
|
|
result['jobLevel'] = self.job_level
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.post_name is not None:
|
|
result['postName'] = self.post_name
|
|
if self.regist_date is not None:
|
|
result['registDate'] = self.regist_date
|
|
if self.super_name is not None:
|
|
result['superName'] = self.super_name
|
|
if self.work_loc_addr is not None:
|
|
result['workLocAddr'] = self.work_loc_addr
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('deptName') is not None:
|
|
self.dept_name = m.get('deptName')
|
|
if m.get('deptNo') is not None:
|
|
self.dept_no = m.get('deptNo')
|
|
if m.get('empSource') is not None:
|
|
self.emp_source = m.get('empSource')
|
|
if m.get('empType') is not None:
|
|
self.emp_type = m.get('empType')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('jobCodeName') is not None:
|
|
self.job_code_name = m.get('jobCodeName')
|
|
if m.get('jobLevel') is not None:
|
|
self.job_level = m.get('jobLevel')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('postName') is not None:
|
|
self.post_name = m.get('postName')
|
|
if m.get('registDate') is not None:
|
|
self.regist_date = m.get('registDate')
|
|
if m.get('superName') is not None:
|
|
self.super_name = m.get('superName')
|
|
if m.get('workLocAddr') is not None:
|
|
self.work_loc_addr = m.get('workLocAddr')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportRegistRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportRegistRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportRegistRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportRegistResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportRegistResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportRegistResponseBody = 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 = HrbrainImportRegistResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportRegularHeaders(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 HrbrainImportRegularRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
dept_name: str = None,
|
|
dept_no: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
job_code_name: str = None,
|
|
job_level: str = None,
|
|
name: str = None,
|
|
plan_regular_date: str = None,
|
|
post_name: str = None,
|
|
regular_date: str = None,
|
|
super_emp_id: str = None,
|
|
super_name: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.dept_name = dept_name
|
|
self.dept_no = dept_no
|
|
self.extend_info = extend_info
|
|
self.job_code_name = job_code_name
|
|
self.job_level = job_level
|
|
self.name = name
|
|
self.plan_regular_date = plan_regular_date
|
|
self.post_name = post_name
|
|
# This parameter is required.
|
|
self.regular_date = regular_date
|
|
self.super_emp_id = super_emp_id
|
|
self.super_name = super_name
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.dept_name is not None:
|
|
result['deptName'] = self.dept_name
|
|
if self.dept_no is not None:
|
|
result['deptNo'] = self.dept_no
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.job_code_name is not None:
|
|
result['jobCodeName'] = self.job_code_name
|
|
if self.job_level is not None:
|
|
result['jobLevel'] = self.job_level
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.plan_regular_date is not None:
|
|
result['planRegularDate'] = self.plan_regular_date
|
|
if self.post_name is not None:
|
|
result['postName'] = self.post_name
|
|
if self.regular_date is not None:
|
|
result['regularDate'] = self.regular_date
|
|
if self.super_emp_id is not None:
|
|
result['superEmpId'] = self.super_emp_id
|
|
if self.super_name is not None:
|
|
result['superName'] = self.super_name
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('deptName') is not None:
|
|
self.dept_name = m.get('deptName')
|
|
if m.get('deptNo') is not None:
|
|
self.dept_no = m.get('deptNo')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('jobCodeName') is not None:
|
|
self.job_code_name = m.get('jobCodeName')
|
|
if m.get('jobLevel') is not None:
|
|
self.job_level = m.get('jobLevel')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('planRegularDate') is not None:
|
|
self.plan_regular_date = m.get('planRegularDate')
|
|
if m.get('postName') is not None:
|
|
self.post_name = m.get('postName')
|
|
if m.get('regularDate') is not None:
|
|
self.regular_date = m.get('regularDate')
|
|
if m.get('superEmpId') is not None:
|
|
self.super_emp_id = m.get('superEmpId')
|
|
if m.get('superName') is not None:
|
|
self.super_name = m.get('superName')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportRegularRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportRegularRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportRegularRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportRegularResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportRegularResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportRegularResponseBody = 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 = HrbrainImportRegularResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportTrainingHeaders(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 HrbrainImportTrainingRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
certif_cnt: str = None,
|
|
credit_score: str = None,
|
|
dept_name: str = None,
|
|
dept_no: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
job_code_name: str = None,
|
|
job_level: str = None,
|
|
name: str = None,
|
|
post_name: str = None,
|
|
train_end_date: str = None,
|
|
train_name: str = None,
|
|
train_start_date: str = None,
|
|
work_no: str = None,
|
|
):
|
|
self.certif_cnt = certif_cnt
|
|
self.credit_score = credit_score
|
|
self.dept_name = dept_name
|
|
self.dept_no = dept_no
|
|
self.extend_info = extend_info
|
|
self.job_code_name = job_code_name
|
|
self.job_level = job_level
|
|
self.name = name
|
|
self.post_name = post_name
|
|
# This parameter is required.
|
|
self.train_end_date = train_end_date
|
|
# This parameter is required.
|
|
self.train_name = train_name
|
|
# This parameter is required.
|
|
self.train_start_date = train_start_date
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.certif_cnt is not None:
|
|
result['certifCnt'] = self.certif_cnt
|
|
if self.credit_score is not None:
|
|
result['creditScore'] = self.credit_score
|
|
if self.dept_name is not None:
|
|
result['deptName'] = self.dept_name
|
|
if self.dept_no is not None:
|
|
result['deptNo'] = self.dept_no
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.job_code_name is not None:
|
|
result['jobCodeName'] = self.job_code_name
|
|
if self.job_level is not None:
|
|
result['jobLevel'] = self.job_level
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.post_name is not None:
|
|
result['postName'] = self.post_name
|
|
if self.train_end_date is not None:
|
|
result['trainEndDate'] = self.train_end_date
|
|
if self.train_name is not None:
|
|
result['trainName'] = self.train_name
|
|
if self.train_start_date is not None:
|
|
result['trainStartDate'] = self.train_start_date
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('certifCnt') is not None:
|
|
self.certif_cnt = m.get('certifCnt')
|
|
if m.get('creditScore') is not None:
|
|
self.credit_score = m.get('creditScore')
|
|
if m.get('deptName') is not None:
|
|
self.dept_name = m.get('deptName')
|
|
if m.get('deptNo') is not None:
|
|
self.dept_no = m.get('deptNo')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('jobCodeName') is not None:
|
|
self.job_code_name = m.get('jobCodeName')
|
|
if m.get('jobLevel') is not None:
|
|
self.job_level = m.get('jobLevel')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('postName') is not None:
|
|
self.post_name = m.get('postName')
|
|
if m.get('trainEndDate') is not None:
|
|
self.train_end_date = m.get('trainEndDate')
|
|
if m.get('trainName') is not None:
|
|
self.train_name = m.get('trainName')
|
|
if m.get('trainStartDate') is not None:
|
|
self.train_start_date = m.get('trainStartDate')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportTrainingRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportTrainingRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportTrainingRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportTrainingResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportTrainingResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportTrainingResponseBody = 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 = HrbrainImportTrainingResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportTransferEvalHeaders(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 HrbrainImportTransferEvalRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
curr_info: Dict[str, Any] = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
name: str = None,
|
|
pre_info: Dict[str, Any] = None,
|
|
transfer_date: str = None,
|
|
transfer_reason: str = None,
|
|
transfer_type: str = None,
|
|
work_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.curr_info = curr_info
|
|
self.extend_info = extend_info
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.pre_info = pre_info
|
|
# This parameter is required.
|
|
self.transfer_date = transfer_date
|
|
# This parameter is required.
|
|
self.transfer_reason = transfer_reason
|
|
# This parameter is required.
|
|
self.transfer_type = transfer_type
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.curr_info is not None:
|
|
result['currInfo'] = self.curr_info
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.pre_info is not None:
|
|
result['preInfo'] = self.pre_info
|
|
if self.transfer_date is not None:
|
|
result['transferDate'] = self.transfer_date
|
|
if self.transfer_reason is not None:
|
|
result['transferReason'] = self.transfer_reason
|
|
if self.transfer_type is not None:
|
|
result['transferType'] = self.transfer_type
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('currInfo') is not None:
|
|
self.curr_info = m.get('currInfo')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('preInfo') is not None:
|
|
self.pre_info = m.get('preInfo')
|
|
if m.get('transferDate') is not None:
|
|
self.transfer_date = m.get('transferDate')
|
|
if m.get('transferReason') is not None:
|
|
self.transfer_reason = m.get('transferReason')
|
|
if m.get('transferType') is not None:
|
|
self.transfer_type = m.get('transferType')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportTransferEvalRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportTransferEvalRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportTransferEvalRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportTransferEvalResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportTransferEvalResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportTransferEvalResponseBody = 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 = HrbrainImportTransferEvalResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainImportWorkExpHeaders(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 HrbrainImportWorkExpRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
company_name: str = None,
|
|
end_date: str = None,
|
|
extend_info: Dict[str, Any] = None,
|
|
job_desc: str = None,
|
|
name: str = None,
|
|
post_name: str = None,
|
|
start_date: str = None,
|
|
work_no: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.company_name = company_name
|
|
# This parameter is required.
|
|
self.end_date = end_date
|
|
self.extend_info = extend_info
|
|
self.job_desc = job_desc
|
|
# This parameter is required.
|
|
self.name = name
|
|
self.post_name = post_name
|
|
# This parameter is required.
|
|
self.start_date = start_date
|
|
# This parameter is required.
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.company_name is not None:
|
|
result['companyName'] = self.company_name
|
|
if self.end_date is not None:
|
|
result['endDate'] = self.end_date
|
|
if self.extend_info is not None:
|
|
result['extendInfo'] = self.extend_info
|
|
if self.job_desc is not None:
|
|
result['jobDesc'] = self.job_desc
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.post_name is not None:
|
|
result['postName'] = self.post_name
|
|
if self.start_date is not None:
|
|
result['startDate'] = self.start_date
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('companyName') is not None:
|
|
self.company_name = m.get('companyName')
|
|
if m.get('endDate') is not None:
|
|
self.end_date = m.get('endDate')
|
|
if m.get('extendInfo') is not None:
|
|
self.extend_info = m.get('extendInfo')
|
|
if m.get('jobDesc') is not None:
|
|
self.job_desc = m.get('jobDesc')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('postName') is not None:
|
|
self.post_name = m.get('postName')
|
|
if m.get('startDate') is not None:
|
|
self.start_date = m.get('startDate')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainImportWorkExpRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[HrbrainImportWorkExpRequestBody] = None,
|
|
corp_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.corp_id = corp_id
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.corp_id is not None:
|
|
result['corpId'] = self.corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = HrbrainImportWorkExpRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('corpId') is not None:
|
|
self.corp_id = m.get('corpId')
|
|
return self
|
|
|
|
|
|
class HrbrainImportWorkExpResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainImportWorkExpResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainImportWorkExpResponseBody = 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 = HrbrainImportWorkExpResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainTalentProfileAttachmentQueryHeaders(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 HrbrainTalentProfileAttachmentQueryRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[str] = None,
|
|
ding_corp_id: str = None,
|
|
):
|
|
self.body = body
|
|
self.ding_corp_id = ding_corp_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.body is not None:
|
|
result['body'] = self.body
|
|
if self.ding_corp_id is not None:
|
|
result['dingCorpId'] = self.ding_corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('body') is not None:
|
|
self.body = m.get('body')
|
|
if m.get('dingCorpId') is not None:
|
|
self.ding_corp_id = m.get('dingCorpId')
|
|
return self
|
|
|
|
|
|
class HrbrainTalentProfileAttachmentQueryResponseBodyContentStaffAttachmentInfoListAttachmentInfoList(TeaModel):
|
|
def __init__(
|
|
self,
|
|
name: str = None,
|
|
url: str = None,
|
|
):
|
|
self.name = name
|
|
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.name is not None:
|
|
result['name'] = self.name
|
|
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('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('url') is not None:
|
|
self.url = m.get('url')
|
|
return self
|
|
|
|
|
|
class HrbrainTalentProfileAttachmentQueryResponseBodyContentStaffAttachmentInfoList(TeaModel):
|
|
def __init__(
|
|
self,
|
|
attachment_info_list: List[HrbrainTalentProfileAttachmentQueryResponseBodyContentStaffAttachmentInfoListAttachmentInfoList] = None,
|
|
work_no: str = None,
|
|
):
|
|
self.attachment_info_list = attachment_info_list
|
|
self.work_no = work_no
|
|
|
|
def validate(self):
|
|
if self.attachment_info_list:
|
|
for k in self.attachment_info_list:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['attachmentInfoList'] = []
|
|
if self.attachment_info_list is not None:
|
|
for k in self.attachment_info_list:
|
|
result['attachmentInfoList'].append(k.to_map() if k else None)
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.attachment_info_list = []
|
|
if m.get('attachmentInfoList') is not None:
|
|
for k in m.get('attachmentInfoList'):
|
|
temp_model = HrbrainTalentProfileAttachmentQueryResponseBodyContentStaffAttachmentInfoListAttachmentInfoList()
|
|
self.attachment_info_list.append(temp_model.from_map(k))
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
return self
|
|
|
|
|
|
class HrbrainTalentProfileAttachmentQueryResponseBodyContent(TeaModel):
|
|
def __init__(
|
|
self,
|
|
staff_attachment_info_list: List[HrbrainTalentProfileAttachmentQueryResponseBodyContentStaffAttachmentInfoList] = None,
|
|
):
|
|
self.staff_attachment_info_list = staff_attachment_info_list
|
|
|
|
def validate(self):
|
|
if self.staff_attachment_info_list:
|
|
for k in self.staff_attachment_info_list:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['staffAttachmentInfoList'] = []
|
|
if self.staff_attachment_info_list is not None:
|
|
for k in self.staff_attachment_info_list:
|
|
result['staffAttachmentInfoList'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.staff_attachment_info_list = []
|
|
if m.get('staffAttachmentInfoList') is not None:
|
|
for k in m.get('staffAttachmentInfoList'):
|
|
temp_model = HrbrainTalentProfileAttachmentQueryResponseBodyContentStaffAttachmentInfoList()
|
|
self.staff_attachment_info_list.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainTalentProfileAttachmentQueryResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
content: HrbrainTalentProfileAttachmentQueryResponseBodyContent = None,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.content = content
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
if self.content:
|
|
self.content.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.content is not None:
|
|
result['content'] = self.content.to_map()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('content') is not None:
|
|
temp_model = HrbrainTalentProfileAttachmentQueryResponseBodyContent()
|
|
self.content = temp_model.from_map(m['content'])
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainTalentProfileAttachmentQueryResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainTalentProfileAttachmentQueryResponseBody = 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 = HrbrainTalentProfileAttachmentQueryResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class HrbrainTalentProfileBasicQueryHeaders(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 HrbrainTalentProfileBasicQueryRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[str] = None,
|
|
ding_corp_id: str = None,
|
|
):
|
|
self.body = body
|
|
self.ding_corp_id = ding_corp_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.body is not None:
|
|
result['body'] = self.body
|
|
if self.ding_corp_id is not None:
|
|
result['dingCorpId'] = self.ding_corp_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('body') is not None:
|
|
self.body = m.get('body')
|
|
if m.get('dingCorpId') is not None:
|
|
self.ding_corp_id = m.get('dingCorpId')
|
|
return self
|
|
|
|
|
|
class HrbrainTalentProfileBasicQueryResponseBodyContentProfileBaseInfoList(TeaModel):
|
|
def __init__(
|
|
self,
|
|
age: str = None,
|
|
birthday: str = None,
|
|
dept_name: str = None,
|
|
dept_no: str = None,
|
|
gender: str = None,
|
|
job_level: str = None,
|
|
jobcode: str = None,
|
|
name: str = None,
|
|
position: str = None,
|
|
seniority_years: str = None,
|
|
super_name: str = None,
|
|
super_work_no: str = None,
|
|
work_no: str = None,
|
|
work_place: str = None,
|
|
):
|
|
self.age = age
|
|
self.birthday = birthday
|
|
self.dept_name = dept_name
|
|
self.dept_no = dept_no
|
|
self.gender = gender
|
|
self.job_level = job_level
|
|
self.jobcode = jobcode
|
|
self.name = name
|
|
self.position = position
|
|
self.seniority_years = seniority_years
|
|
self.super_name = super_name
|
|
self.super_work_no = super_work_no
|
|
self.work_no = work_no
|
|
self.work_place = work_place
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.age is not None:
|
|
result['age'] = self.age
|
|
if self.birthday is not None:
|
|
result['birthday'] = self.birthday
|
|
if self.dept_name is not None:
|
|
result['deptName'] = self.dept_name
|
|
if self.dept_no is not None:
|
|
result['deptNo'] = self.dept_no
|
|
if self.gender is not None:
|
|
result['gender'] = self.gender
|
|
if self.job_level is not None:
|
|
result['jobLevel'] = self.job_level
|
|
if self.jobcode is not None:
|
|
result['jobcode'] = self.jobcode
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.position is not None:
|
|
result['position'] = self.position
|
|
if self.seniority_years is not None:
|
|
result['seniorityYears'] = self.seniority_years
|
|
if self.super_name is not None:
|
|
result['superName'] = self.super_name
|
|
if self.super_work_no is not None:
|
|
result['superWorkNo'] = self.super_work_no
|
|
if self.work_no is not None:
|
|
result['workNo'] = self.work_no
|
|
if self.work_place is not None:
|
|
result['workPlace'] = self.work_place
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('age') is not None:
|
|
self.age = m.get('age')
|
|
if m.get('birthday') is not None:
|
|
self.birthday = m.get('birthday')
|
|
if m.get('deptName') is not None:
|
|
self.dept_name = m.get('deptName')
|
|
if m.get('deptNo') is not None:
|
|
self.dept_no = m.get('deptNo')
|
|
if m.get('gender') is not None:
|
|
self.gender = m.get('gender')
|
|
if m.get('jobLevel') is not None:
|
|
self.job_level = m.get('jobLevel')
|
|
if m.get('jobcode') is not None:
|
|
self.jobcode = m.get('jobcode')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('position') is not None:
|
|
self.position = m.get('position')
|
|
if m.get('seniorityYears') is not None:
|
|
self.seniority_years = m.get('seniorityYears')
|
|
if m.get('superName') is not None:
|
|
self.super_name = m.get('superName')
|
|
if m.get('superWorkNo') is not None:
|
|
self.super_work_no = m.get('superWorkNo')
|
|
if m.get('workNo') is not None:
|
|
self.work_no = m.get('workNo')
|
|
if m.get('workPlace') is not None:
|
|
self.work_place = m.get('workPlace')
|
|
return self
|
|
|
|
|
|
class HrbrainTalentProfileBasicQueryResponseBodyContent(TeaModel):
|
|
def __init__(
|
|
self,
|
|
profile_base_info_list: List[HrbrainTalentProfileBasicQueryResponseBodyContentProfileBaseInfoList] = None,
|
|
):
|
|
self.profile_base_info_list = profile_base_info_list
|
|
|
|
def validate(self):
|
|
if self.profile_base_info_list:
|
|
for k in self.profile_base_info_list:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['profileBaseInfoList'] = []
|
|
if self.profile_base_info_list is not None:
|
|
for k in self.profile_base_info_list:
|
|
result['profileBaseInfoList'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.profile_base_info_list = []
|
|
if m.get('profileBaseInfoList') is not None:
|
|
for k in m.get('profileBaseInfoList'):
|
|
temp_model = HrbrainTalentProfileBasicQueryResponseBodyContentProfileBaseInfoList()
|
|
self.profile_base_info_list.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class HrbrainTalentProfileBasicQueryResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
content: HrbrainTalentProfileBasicQueryResponseBodyContent = None,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.content = content
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
if self.content:
|
|
self.content.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.content is not None:
|
|
result['content'] = self.content.to_map()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('content') is not None:
|
|
temp_model = HrbrainTalentProfileBasicQueryResponseBodyContent()
|
|
self.content = temp_model.from_map(m['content'])
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class HrbrainTalentProfileBasicQueryResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: HrbrainTalentProfileBasicQueryResponseBody = 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 = HrbrainTalentProfileBasicQueryResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class StaffLabelRecordsQueryHeaders(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 StaffLabelRecordsQueryRequestBodyLabels(TeaModel):
|
|
def __init__(
|
|
self,
|
|
code: str = None,
|
|
type_code: str = None,
|
|
):
|
|
self.code = code
|
|
self.type_code = type_code
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.code is not None:
|
|
result['code'] = self.code
|
|
if self.type_code is not None:
|
|
result['typeCode'] = self.type_code
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('code') is not None:
|
|
self.code = m.get('code')
|
|
if m.get('typeCode') is not None:
|
|
self.type_code = m.get('typeCode')
|
|
return self
|
|
|
|
|
|
class StaffLabelRecordsQueryRequestBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
labels: List[StaffLabelRecordsQueryRequestBodyLabels] = None,
|
|
user_id: str = None,
|
|
):
|
|
self.labels = labels
|
|
self.user_id = user_id
|
|
|
|
def validate(self):
|
|
if self.labels:
|
|
for k in self.labels:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['labels'] = []
|
|
if self.labels is not None:
|
|
for k in self.labels:
|
|
result['labels'].append(k.to_map() if k else None)
|
|
if self.user_id is not None:
|
|
result['userId'] = self.user_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.labels = []
|
|
if m.get('labels') is not None:
|
|
for k in m.get('labels'):
|
|
temp_model = StaffLabelRecordsQueryRequestBodyLabels()
|
|
self.labels.append(temp_model.from_map(k))
|
|
if m.get('userId') is not None:
|
|
self.user_id = m.get('userId')
|
|
return self
|
|
|
|
|
|
class StaffLabelRecordsQueryRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body: List[StaffLabelRecordsQueryRequestBody] = None,
|
|
ding_corp_id: str = None,
|
|
max_results: int = None,
|
|
next_token: str = None,
|
|
):
|
|
self.body = body
|
|
self.ding_corp_id = ding_corp_id
|
|
self.max_results = max_results
|
|
self.next_token = next_token
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
for k in self.body:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['body'] = []
|
|
if self.body is not None:
|
|
for k in self.body:
|
|
result['body'].append(k.to_map() if k else None)
|
|
if self.ding_corp_id is not None:
|
|
result['dingCorpId'] = self.ding_corp_id
|
|
if self.max_results is not None:
|
|
result['maxResults'] = self.max_results
|
|
if self.next_token is not None:
|
|
result['nextToken'] = self.next_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.body = []
|
|
if m.get('body') is not None:
|
|
for k in m.get('body'):
|
|
temp_model = StaffLabelRecordsQueryRequestBody()
|
|
self.body.append(temp_model.from_map(k))
|
|
if m.get('dingCorpId') is not None:
|
|
self.ding_corp_id = m.get('dingCorpId')
|
|
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')
|
|
return self
|
|
|
|
|
|
class StaffLabelRecordsQueryResponseBodyContentDataLabelsOptions(TeaModel):
|
|
def __init__(
|
|
self,
|
|
label: str = None,
|
|
tip: str = None,
|
|
value: str = None,
|
|
):
|
|
self.label = label
|
|
self.tip = tip
|
|
self.value = value
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.label is not None:
|
|
result['label'] = self.label
|
|
if self.tip is not None:
|
|
result['tip'] = self.tip
|
|
if self.value is not None:
|
|
result['value'] = self.value
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('label') is not None:
|
|
self.label = m.get('label')
|
|
if m.get('tip') is not None:
|
|
self.tip = m.get('tip')
|
|
if m.get('value') is not None:
|
|
self.value = m.get('value')
|
|
return self
|
|
|
|
|
|
class StaffLabelRecordsQueryResponseBodyContentDataLabels(TeaModel):
|
|
def __init__(
|
|
self,
|
|
code: str = None,
|
|
guid: str = None,
|
|
name: str = None,
|
|
options: List[StaffLabelRecordsQueryResponseBodyContentDataLabelsOptions] = None,
|
|
type_code: str = None,
|
|
type_name: str = None,
|
|
value: str = None,
|
|
):
|
|
self.code = code
|
|
self.guid = guid
|
|
self.name = name
|
|
self.options = options
|
|
self.type_code = type_code
|
|
self.type_name = type_name
|
|
self.value = value
|
|
|
|
def validate(self):
|
|
if self.options:
|
|
for k in self.options:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.code is not None:
|
|
result['code'] = self.code
|
|
if self.guid is not None:
|
|
result['guid'] = self.guid
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
result['options'] = []
|
|
if self.options is not None:
|
|
for k in self.options:
|
|
result['options'].append(k.to_map() if k else None)
|
|
if self.type_code is not None:
|
|
result['typeCode'] = self.type_code
|
|
if self.type_name is not None:
|
|
result['typeName'] = self.type_name
|
|
if self.value is not None:
|
|
result['value'] = self.value
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('code') is not None:
|
|
self.code = m.get('code')
|
|
if m.get('guid') is not None:
|
|
self.guid = m.get('guid')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
self.options = []
|
|
if m.get('options') is not None:
|
|
for k in m.get('options'):
|
|
temp_model = StaffLabelRecordsQueryResponseBodyContentDataLabelsOptions()
|
|
self.options.append(temp_model.from_map(k))
|
|
if m.get('typeCode') is not None:
|
|
self.type_code = m.get('typeCode')
|
|
if m.get('typeName') is not None:
|
|
self.type_name = m.get('typeName')
|
|
if m.get('value') is not None:
|
|
self.value = m.get('value')
|
|
return self
|
|
|
|
|
|
class StaffLabelRecordsQueryResponseBodyContentData(TeaModel):
|
|
def __init__(
|
|
self,
|
|
labels: List[StaffLabelRecordsQueryResponseBodyContentDataLabels] = None,
|
|
user_id: str = None,
|
|
):
|
|
self.labels = labels
|
|
self.user_id = user_id
|
|
|
|
def validate(self):
|
|
if self.labels:
|
|
for k in self.labels:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['labels'] = []
|
|
if self.labels is not None:
|
|
for k in self.labels:
|
|
result['labels'].append(k.to_map() if k else None)
|
|
if self.user_id is not None:
|
|
result['userId'] = self.user_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.labels = []
|
|
if m.get('labels') is not None:
|
|
for k in m.get('labels'):
|
|
temp_model = StaffLabelRecordsQueryResponseBodyContentDataLabels()
|
|
self.labels.append(temp_model.from_map(k))
|
|
if m.get('userId') is not None:
|
|
self.user_id = m.get('userId')
|
|
return self
|
|
|
|
|
|
class StaffLabelRecordsQueryResponseBodyContent(TeaModel):
|
|
def __init__(
|
|
self,
|
|
data: List[StaffLabelRecordsQueryResponseBodyContentData] = None,
|
|
max_results: int = None,
|
|
next_token: str = None,
|
|
total_countt: int = None,
|
|
):
|
|
self.data = data
|
|
self.max_results = max_results
|
|
self.next_token = next_token
|
|
self.total_countt = total_countt
|
|
|
|
def validate(self):
|
|
if self.data:
|
|
for k in self.data:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['data'] = []
|
|
if self.data is not None:
|
|
for k in self.data:
|
|
result['data'].append(k.to_map() if k else None)
|
|
if self.max_results is not None:
|
|
result['maxResults'] = self.max_results
|
|
if self.next_token is not None:
|
|
result['nextToken'] = self.next_token
|
|
if self.total_countt is not None:
|
|
result['totalCountt'] = self.total_countt
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.data = []
|
|
if m.get('data') is not None:
|
|
for k in m.get('data'):
|
|
temp_model = StaffLabelRecordsQueryResponseBodyContentData()
|
|
self.data.append(temp_model.from_map(k))
|
|
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('totalCountt') is not None:
|
|
self.total_countt = m.get('totalCountt')
|
|
return self
|
|
|
|
|
|
class StaffLabelRecordsQueryResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
content: StaffLabelRecordsQueryResponseBodyContent = None,
|
|
request_id: str = None,
|
|
result: bool = None,
|
|
success: bool = None,
|
|
):
|
|
self.content = content
|
|
self.request_id = request_id
|
|
self.result = result
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
if self.content:
|
|
self.content.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.content is not None:
|
|
result['content'] = self.content.to_map()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
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('content') is not None:
|
|
temp_model = StaffLabelRecordsQueryResponseBodyContent()
|
|
self.content = temp_model.from_map(m['content'])
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class StaffLabelRecordsQueryResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: StaffLabelRecordsQueryResponseBody = 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 = StaffLabelRecordsQueryResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class SyncDataHeaders(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 SyncDataRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
content: str = None,
|
|
data_id: str = None,
|
|
etl_time: str = None,
|
|
project_id: str = None,
|
|
schema_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.content = content
|
|
# This parameter is required.
|
|
self.data_id = data_id
|
|
# This parameter is required.
|
|
self.etl_time = etl_time
|
|
# This parameter is required.
|
|
self.project_id = project_id
|
|
# This parameter is required.
|
|
self.schema_id = schema_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.content is not None:
|
|
result['content'] = self.content
|
|
if self.data_id is not None:
|
|
result['dataId'] = self.data_id
|
|
if self.etl_time is not None:
|
|
result['etlTime'] = self.etl_time
|
|
if self.project_id is not None:
|
|
result['projectId'] = self.project_id
|
|
if self.schema_id is not None:
|
|
result['schemaId'] = self.schema_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('content') is not None:
|
|
self.content = m.get('content')
|
|
if m.get('dataId') is not None:
|
|
self.data_id = m.get('dataId')
|
|
if m.get('etlTime') is not None:
|
|
self.etl_time = m.get('etlTime')
|
|
if m.get('projectId') is not None:
|
|
self.project_id = m.get('projectId')
|
|
if m.get('schemaId') is not None:
|
|
self.schema_id = m.get('schemaId')
|
|
return self
|
|
|
|
|
|
class SyncDataResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
success: bool = None,
|
|
):
|
|
self.success = success
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.success is not None:
|
|
result['success'] = self.success
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('success') is not None:
|
|
self.success = m.get('success')
|
|
return self
|
|
|
|
|
|
class SyncDataResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: SyncDataResponseBody = 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 = SyncDataResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|