5268 lines
233 KiB
Python
5268 lines
233 KiB
Python
from __future__ import annotations
|
|
from typing import Optional, Any
|
|
from . import base_api
|
|
|
|
|
|
class SurveillanceStation(base_api.BaseApi):
|
|
|
|
def surveillance_station_info(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Info'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetInfo'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def camera_save(self, id: str = None,
|
|
name: str = None,
|
|
dsld: int = None,
|
|
newName: str = None,
|
|
ip: str = None,
|
|
port: int = None,
|
|
vendor: str = None,
|
|
model: str = None,
|
|
userName: str = None,
|
|
password: str = None,
|
|
videoCodec: int = None,
|
|
audioCodec: int = None,
|
|
tvStandard: int = None,
|
|
channel: str = None,
|
|
userDefinePath: str = None,
|
|
fov: str = None,
|
|
streamXX: Any = None,
|
|
recordTime: int = None,
|
|
preRecordTime: int = None,
|
|
postRecordTime: int = None,
|
|
enableRecordingKeepDays: bool = None,
|
|
recordingKeepDays: int = None,
|
|
enableRecordingKeepSize: bool = None,
|
|
recordingKeepSize: int = None,
|
|
enableLowProfile: bool = None,
|
|
recordSchedule: list[int] = None,
|
|
rtspPathTimeout: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Camera'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def camera_list(self, idList: str = None,
|
|
offset: int = None,
|
|
limit: int = None,
|
|
blFromCamList: bool = None,
|
|
blIncludeDeletedCam: bool = None,
|
|
privCamType: str = None,
|
|
basic: bool = None,
|
|
streamInfo: bool = None,
|
|
blPrivilege: bool = None,
|
|
camStm: int = None) -> dict[str, object] | str:
|
|
|
|
api_name = 'SYNO.SurveillanceStation.Camera'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_camera_info(self,
|
|
cameraIds: int = None,
|
|
privCamType: int = 1,
|
|
blIncludeDeletedCam: bool = True,
|
|
basic: bool = True,
|
|
streamInfo: bool = True,
|
|
optimize: bool = True,
|
|
ptz: bool = True,
|
|
eventDetection: bool = True,
|
|
deviceOutCap: bool = True,
|
|
fisheye: bool = True,
|
|
camAppInfo: bool = True) -> dict[str, object] | str:
|
|
'''
|
|
This function return information about a camera.
|
|
|
|
cameraIds : This parameter is named cameraIds in the API documentation but it refer to 1 camera ID
|
|
|
|
privCamType: int = 1
|
|
SYNO.SS.CamPriv.LIVEVIEW = 1;
|
|
SYNO.SS.CamPriv.PLAYBACK = 2;
|
|
SYNO.SS.CamPriv.LENS = 4;
|
|
SYNO.SS.CamPriv.AUDIO = 8;
|
|
SYNO.SS.CamPriv.DIGIOUT = 16;
|
|
|
|
All other parameters must be let to default value
|
|
'''
|
|
|
|
api_name = 'SYNO.SurveillanceStation.Camera'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['minVersion'], 'method': 'GetInfo'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def camera_list_group(self,
|
|
offset: int = None,
|
|
limit: int = None) -> dict[str, object] | str:
|
|
|
|
api_name = 'SYNO.SurveillanceStation.Camera'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListGroup'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_snapshot(self,
|
|
id: Any = None,
|
|
name: str = None,
|
|
dsld: int = None,
|
|
profileType: int = 1) -> str:
|
|
''' By default, the profileType is 1, which is the default profile.
|
|
Binary data is returned, so the response is not a json object.
|
|
'''
|
|
api_name = 'SYNO.SurveillanceStation.Camera'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetSnapshot'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
## Make sure to disable json response, as the response is a binary file
|
|
## Return only the content of the response where binary data is stored
|
|
return self.request_data(api_name, api_path, req_param, response_json=False).content
|
|
|
|
def enable_camera(self,
|
|
idList: str = None,
|
|
blIncludeDeletedCam: bool = False) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Camera'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enable'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def disable_camera(self,
|
|
idList: str = None,
|
|
blIncludeDeletedCam: bool = False) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Camera'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Disable'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_capability_by_cam_id(self, cameraId: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Camera'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetCapabilityByCamId', 'cameraId': cameraId}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def count_occupied_size(self, camId: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Camera'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetOccupiedSize', 'camId': camId}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def is_shortcut_valid(self, cameraId: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Camera'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CheckCamValid', 'cameraId': cameraId}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_live_path(self, idList: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Camera'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetLiveViewPath', 'idList': idList}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def audio_event_enum(self, camId: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Event'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'AudioEnum', 'camId': camId}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def alarm_event_enum(self, camId: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Event'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'AlarmEnum', 'camId': camId}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def md_parameter_save(self, camId: int = None,
|
|
source: int = None,
|
|
mode: int = None,
|
|
sensitivity: int = None,
|
|
threshold: int = None,
|
|
objectSize: int = None,
|
|
percentage: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Event'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'MDParamSave'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def motion_event_enum(self, camId: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Event'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'MotionEnum', 'camId': camId}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def motion_parameter_save(self,
|
|
camId: int = None,
|
|
source: int = None,
|
|
mode: int = None,
|
|
keep: bool = None,
|
|
level: int = None) -> dict[str, object] | str:
|
|
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Event'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ADParamSave'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def di_parameter_save(self,
|
|
camId: int = None,
|
|
idx: int = None,
|
|
keep: bool = None,
|
|
normal: int = None) -> dict[str, object] | str:
|
|
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Event'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DIParamSave'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def alarm_sts_polling(self,
|
|
camId: int = None,
|
|
timeOut: int = None,
|
|
keep: Any = None) -> dict[str, object] | str: # TODO not working
|
|
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Event'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'AlarmStsPolling'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def td_parameter_save(self,
|
|
camId: int = None,
|
|
source: int = None,
|
|
keep: Any = None,
|
|
duration: int = None) -> dict[str, object] | str:
|
|
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Event'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'TDParamSave'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enumerate_camera_group(self, privCamType: int = None) -> dict[str, object] | str:
|
|
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Group'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enum', 'privCamType': privCamType}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_specific_group(self, groupList: Any = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Group'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save', 'groupList': groupList}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_specific_groups(self, Id: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Group'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete', 'id': Id}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enumerate_group_information(self, camServerId: int = None,
|
|
shareName: str = None,
|
|
archiveName: str = None,
|
|
camlist: Any = None,
|
|
actFromHost: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Import'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enumerate_camera_from_archive(self,
|
|
shareName: str = None,
|
|
archiveName: str = None,
|
|
serverId: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Import'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ArchiveCamEnum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enumerate_archive_from_folder(self,
|
|
shareName: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Import'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ArchiveEnum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def check_available_size_of_sdcard(self,
|
|
camId: Any = None,
|
|
host: str = None,
|
|
port: str = None,
|
|
user: str = None,
|
|
passw: str = None,
|
|
vendor: str = None,
|
|
model: str = None,
|
|
ch: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Wizard'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ArchiveEnum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
if key is passw:
|
|
req_param[str('pass')] = val
|
|
else:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def check_licence_quota(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Wizard'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CheckQuota'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def format_specific_sd_card(self,
|
|
camId: Any = None,
|
|
host: str = None,
|
|
port: str = None,
|
|
user: str = None,
|
|
passw: str = None,
|
|
vendor: str = None,
|
|
model: str = None,
|
|
ch: str = None,
|
|
timeout: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Wizard'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'FormatSDCard'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
if key is passw:
|
|
req_param[str('pass')] = val
|
|
else:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def quick_create_single_camera(self,
|
|
camServerId: Any = None,
|
|
actFromHost: bool = None,
|
|
camStreamingType: str = None,
|
|
camName: str = None,
|
|
camIP: str = None,
|
|
camPort: str = None,
|
|
camVendor: str = None,
|
|
camModel: str = None,
|
|
camMountType: int = None,
|
|
camChannel: str = None,
|
|
camVideoType: str = None,
|
|
camAudioType: str = None,
|
|
camSourcePath: str = None,
|
|
camUserName: str = None,
|
|
camPassWord: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Wizard'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'QuickCreate'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def move_camera_lens(self,
|
|
cameraId: Any = None,
|
|
direction: str = None,
|
|
speed: int = None,
|
|
moveType: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Move'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def camera_lens_zoom(self,
|
|
cameraId: Any = None,
|
|
control: Any = None,
|
|
moveType: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Zoom'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_preset_ptz_camera(self,
|
|
cameraId: Any = None,
|
|
offset: int = None,
|
|
limit: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def move_camera_lens_to_preset_position(self,
|
|
cameraId: Any = None,
|
|
presetId: Any = None,
|
|
position: Any = None,
|
|
speed: Any = None,
|
|
type: Any = None,
|
|
isPatrol: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GoPreset'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_patrol_cameras(self,
|
|
cameraId: Any = None,
|
|
offset: int = None,
|
|
limit: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListPatrol'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def force_cam_to_execute_patrol(self,
|
|
cameraId: Any = None,
|
|
patrolId: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'RunPatrol'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def focus_camera(self,
|
|
cameraId: Any = None,
|
|
control: Any = None,
|
|
moveType: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Focus'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def control_camera_iris_in_out(self,
|
|
cameraId: Any = None,
|
|
control: Any = None,
|
|
moveType: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Iris'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def auto_focus(self, cameraId: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'AutoFocus'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def move_cam_lens_to_absolute_position(self,
|
|
posX: int = None,
|
|
posY: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'AbsPtz'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def move_cam_to_home_position(self,
|
|
cameraId: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Home'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def auto_pan_camera(self,
|
|
cameraId: Any = None,
|
|
moveType: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'AutoPan'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def start_stop_object_tracking(self,
|
|
cameraId: Any = None,
|
|
moveType: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ObjTracking'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def start_stop_external_recording(self,
|
|
cameraId: Any = None,
|
|
action: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.ExternalRecording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Record'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def query_event_list_by_filter(self,
|
|
offset: int = None,
|
|
limit: int = None,
|
|
cameraIds: str = None,
|
|
fromTime: int = None,
|
|
toTime: int = None,
|
|
dsld: int = None,
|
|
mountId: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_recordings(self,
|
|
idList: int = None,
|
|
dsld: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_events_by_filter(self,
|
|
reason: str = None,
|
|
cameraIds: str = None,
|
|
fromTime: Any = None,
|
|
toTime: Any = None,
|
|
locked: int = None,
|
|
evtSrcType: int = None,
|
|
evtSrcId: int = None,
|
|
blIncludeSnapshot: bool = None,
|
|
includeAllCam: bool = None,
|
|
from_end: int = None,
|
|
from_start: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DeleteFilter'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_all_recordings(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DeleteAll'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def apply_settings_advance_tab(self,
|
|
rotateUnrecogCam: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ApplyAdvanced'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def count_by_number_of_event(self,
|
|
offset: bool = None,
|
|
limit: int = None,
|
|
reason: str = None,
|
|
cameraIds: str = None,
|
|
fromTime: int = None,
|
|
toTime: int = None,
|
|
locked: int = None,
|
|
evtSrcType: int = None,
|
|
evtSrcId: int = None,
|
|
blIncludeSnapshot: bool = None,
|
|
includeAllCam: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CountByCategory'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def keep_event_play_alive(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Keepalive'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def stop_recording_event(self,
|
|
idList: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Trunc'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def load_settings_in_advanced_tab(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'LoadAdvanced'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def lock_selected_event(self,
|
|
reason: str = None,
|
|
cameraIds: str = None,
|
|
fromTime: int = None,
|
|
toTime: int = None,
|
|
locked: int = None,
|
|
evtSrcType: int = None,
|
|
evtSrcId: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'LockFilter'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def unlock_selected_event(self,
|
|
idList: str = None,
|
|
dsld: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Unlock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def unlock_selected_filter_event(self,
|
|
reason: str = None,
|
|
cameraIds: str = None,
|
|
fromTime: int = None,
|
|
toTime: int = None,
|
|
locked: int = None,
|
|
evtSrcType: int = None,
|
|
evtSrcId: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'UnlockFilter'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def lock_selected_recordings(self,
|
|
idList: str = None,
|
|
dsld: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Lock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def download_recordings(self,
|
|
id: int = None,
|
|
mountId: int = None,
|
|
offsetTimeMs: int = None,
|
|
playTimeMs: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Download'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param, response_json=False)
|
|
|
|
def check_if_recording_playable(self,
|
|
eventId: int = None,
|
|
chkDetail: bool = None,
|
|
mountId: int = None,
|
|
dsld: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CheckEventValid'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def play_specific_recording(self,
|
|
recordingId: int = None,
|
|
alertRecording: bool = None,
|
|
mountId: int = None,
|
|
dsld: int = None,
|
|
videoCodec: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Stream'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def download_merged_recording_files(self,
|
|
camId: int = None,
|
|
fromTime: int = None,
|
|
toTime: int = None,
|
|
fileName: str = None) -> dict[str, object] | str: # TODO not working
|
|
|
|
"""Download the merged files of UTC time range recordings of target camera.
|
|
If there are different resolution or codec within UTC time range, the recordings will merge as much as possible
|
|
and downlod file will be a zip file.
|
|
|
|
This method will start a task which have keep-alive mechanism.
|
|
Use GetRangeExportProgress method to get newest progress and keep-alive.
|
|
After receiving progress 100, use OnRangeExportDone method to download exported recording within 1
|
|
minutes.
|
|
If you want to cancel range export task, just do not send GetRangeExportProgress method or
|
|
OnRangeExportDone method. System will cleanup processed files itself."""
|
|
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'RangeExport'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_newest_progress_keep_alive(self, dlid: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetRangeExportProgress'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def download_recording_from_target(self,
|
|
dlid: int = None,
|
|
fileName: str = None) -> dict[str, object] | str: # TODO not working
|
|
|
|
"""Response
|
|
MP4 or zip file data.
|
|
The response type can be found in fileExt of GetRangeExportProgress method response when progress 100.
|
|
|
|
Note
|
|
GetRangeExportProgress method must be sent within 1 minute after corresponding RangeExport method task
|
|
is completed, otherwise the exported recordings will be cleared.
|
|
|
|
2.3.11.20 API Error Code
|
|
Code Description
|
|
400 Execution failed.
|
|
401 Parameter invalid.
|
|
405 CMS server connection failed.
|
|
414 Some events not exist.
|
|
439 Too many items selected."""
|
|
|
|
api_name = 'SYNO.SurveillanceStation.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'OnRangeExportDone'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def handle_load_event_export(self,
|
|
start: int = None,
|
|
limit: bool = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Recording.Export'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Load'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def check_name_export_event(self,
|
|
dsId: int = None,
|
|
name: int = None,
|
|
share: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Recording.Export'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CheckName'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_camera_information_list(self,
|
|
dslld: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Recording.Export'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CamEnum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def check_destination_folder_availability(self,
|
|
freeSize: int = None,
|
|
startTime: int = None,
|
|
stopTime: int = None,
|
|
camIdList: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Recording.Export'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CheckAvailableExport'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def handle_save_event_export(self,
|
|
name: str = None,
|
|
srcDsId: int = None,
|
|
dstDsId: int = None,
|
|
dstdir: str = None,
|
|
freesize: int = None,
|
|
start_time: int = None,
|
|
stop_time: int = None,
|
|
isoverwrite: int = None,
|
|
camlistid: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Recording.Export'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_event_export_info_from_recording_server(self,
|
|
start_time: int = None,
|
|
stop_time: int = None,
|
|
camlistid: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Recording.Export'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetEvtExpInfo'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def load_event_mount(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Recording.Mount'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Load'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def redirect_webapi_to_target_ds(self,
|
|
dsId: int = None,
|
|
webAPI: Any = None) -> dict[str, object] | str: # TODO not working
|
|
|
|
"""webAPI Array of <webAPI_info>
|
|
|
|
Example:
|
|
webAPI={"api": "SYNO.SurveillanceStation.AddOns", "version": 1, "method":
|
|
"List"} """
|
|
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Redirect'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def modify_share_privilege(self,
|
|
privSet: int = None,
|
|
shareName: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Load'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def apply_option_settings(self,
|
|
central_auto_video_relay: bool = None,
|
|
central_enable: bool = None,
|
|
central_mode: str = None,
|
|
central_rec_mask_mode: bool = None,
|
|
central_rec_sync_time: bool = None,
|
|
nvr_enable: bool = None,
|
|
nvr_lang: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ApplyOption'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_cms_info(self,
|
|
isPolling: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetInfo'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_log_recording_data_from_target_ds(self,
|
|
syncType: int = None,
|
|
syncTargetId: int = None,
|
|
limit: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DoSyncData'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_samba_service(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CheckSambaEnabled'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def check_if_samba_on_and_rec_enabled(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'BatCheckSambaService'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_encoded_single_image_of_camera(self,
|
|
camId: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetMDSnapshot'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_cms_status(self,
|
|
camId: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetCMSStatus'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enable_smb_service(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EnableSamba'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def notify_slave_ds_to_disconnect(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'NotifyCMSBreak'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def lock_recording_server_prevent_setting_change(self,
|
|
locked: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'LockSelf'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enable_ds_into_recording_server(self,
|
|
adminUsername: str = None,
|
|
adminPasswd: str = None,
|
|
central_rec_mask_mode: str = None,
|
|
central_rec_sync_time: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.CMS.GetDsStatus'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EnableCMS'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def unpair_recording_servers(self,
|
|
adminUsername: str = None,
|
|
key: str = None,
|
|
mac: str = None,
|
|
cmsMode: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.CMS.GetDsStatus'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'UnPair'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_free_memory_size(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.CMS.GetDsStatus'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetFreeSpace'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def handle_slave_ds(self,
|
|
lock: bool = None,
|
|
adminUsername: str = None,
|
|
key: str = None,
|
|
mac: str = None,
|
|
masterAuthKey: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.CMS.GetDsStatus'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Lock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_target_ds_info(self,
|
|
slaveDslp: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.CMS.GetDsStatus'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Test'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def logout_slave_ds(self,
|
|
adminUsername: str = None,
|
|
key: str = None,
|
|
mac: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.CMS.GetDsStatus'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Logout'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def pair_slave_ds(self,
|
|
dsname: str = None,
|
|
slaveDslp: str = None,
|
|
port: int = None,
|
|
masterAuthKey: str = None,
|
|
model: str = None,
|
|
mac: str = None,
|
|
cms_locked: bool = None,
|
|
cms_masked: bool = None,
|
|
cms_sync_time: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS.GetDsStatus'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Pair'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def login_slave_ds(self,
|
|
adminUsername: str = None,
|
|
key: str = None,
|
|
mac: str = None,
|
|
masterAuthKey: str = None,
|
|
hostName: str = None,
|
|
hostPort: int = None,
|
|
ignoreAuthError: str = None,
|
|
hostDisconnect: bool = None,
|
|
blUpdateVolSpace: bool = None,
|
|
enable_rec: bool = None,
|
|
cms_locked: bool = None,
|
|
cms_masked: bool = None,
|
|
cms_sync_time: bool = None) -> dict[str, object] | str: # TODO not working
|
|
|
|
"""2.3.15.9 API Error Code
|
|
Code Description
|
|
400 Execution failed.
|
|
401 Invalid parameter.
|
|
415 message connect failed. """
|
|
|
|
api_name = 'SYNO.SurveillanceStation.CMS.GetDsStatus'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Login'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_slave_ds(self,
|
|
slavedsName: str = None,
|
|
slavedsModel: str = None,
|
|
slavedsPort: int = None,
|
|
slavedsVersion: str = None,
|
|
slavedsMaxCamNum: int = None,
|
|
slavedsId: str = None,
|
|
slavedsIP: str = None,
|
|
slavedsEnable: int = None,
|
|
slavedsCamCnt: bool = None,
|
|
adminUsername: str = None,
|
|
adminPasswd: str = None,
|
|
cms_locked: bool = None,
|
|
cms_masked: bool = None,
|
|
cms_sync_time: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.CMS.GetDsStatus'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def load_slave_ds_list(self,
|
|
blNeedStatus: bool = None,
|
|
blGetSortInfo: bool = None,
|
|
blRuntimeInfo: bool = None,
|
|
dslds: str = None,
|
|
sortInfo: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.CMS.SlavedsList'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Load'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def count_number_of_logs(self,
|
|
slavedsName: str = None,
|
|
start: int = None,
|
|
limit: int = None,
|
|
level: str = None,
|
|
filterCamera: str = None,
|
|
cameraIds: str = None,
|
|
dsfrom: int = None,
|
|
to: int = None,
|
|
keyword: str = None,
|
|
keywordDsId: str = None,
|
|
time2String: str = None,
|
|
dsId: str = None,
|
|
srcType: int = None,
|
|
timezoneOffset: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Log'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CountByCategory'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
if key == 'dsfrom':
|
|
req_param[str('from')] = val
|
|
else:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def clear_selected_logs(self,
|
|
blClearAll: bool = None,
|
|
level: int = None,
|
|
dsId: int = None,
|
|
filterCamera: str = None,
|
|
cameraIds: str = None,
|
|
dsfrom: int = None,
|
|
to: int = None,
|
|
keyword: str = None,
|
|
keywordDsId: str = None,
|
|
srcType: int = None,
|
|
timezoneOffset: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Log'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Clear'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
if key == 'dsfrom':
|
|
req_param[str('from')] = val
|
|
else:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_information_log(self,
|
|
start: int = None,
|
|
limit: int = None,
|
|
level: str = None,
|
|
filterCamera: str = None,
|
|
cameraIds: str = None,
|
|
dsfrom: int = None,
|
|
to: int = None,
|
|
keyword: str = None,
|
|
keywordDsId: str = None,
|
|
time2String: str = None,
|
|
dsId: int = None,
|
|
srcType: int = None,
|
|
all: bool = None,
|
|
blIncludeRecCnt: str = None,
|
|
blIncludeAuInfo: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Log'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
if key == 'dsfrom':
|
|
req_param[str('from')] = val
|
|
else:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_advanced_settings_logs(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Log'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetSetting'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_advanced_setting_logs(self,
|
|
data: Any = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Log'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetSetting', 'data': data }
|
|
|
|
"""data example:
|
|
|
|
data=[{"SSLogType":321912835,"enable":1},{"SSLogType":321912836,"enable":0}]"""
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def load_license_data(self,
|
|
num_only: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.License'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Load', 'num_only': num_only}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def check_license_quota(self,
|
|
camList: Any = None,
|
|
camServerId: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.License'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CheckQuota'}
|
|
|
|
"""camList example:
|
|
|
|
camList = [{"ip": "10.13.22.141", "model": "DCS-3110", "vendor": "DLink", "port": 80}]"""
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_http_video_stream(self,
|
|
writeHeader: bool = None,
|
|
analyevent: bool = None,
|
|
mountId: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Stream'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EventStream'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_action_rule(self,
|
|
id: int = None,
|
|
name: str = None,
|
|
ruleType: int = None,
|
|
actType: int = None,
|
|
evtSrc: int = None,
|
|
evtDsId: int = None,
|
|
evtDevId: int = None,
|
|
evtId: int = None,
|
|
evtItem: int = None,
|
|
evtMinIntvl: int = None,
|
|
Actions: Any = None,
|
|
actSchedule: str = None,
|
|
Id: int = None,
|
|
actSrc: int = None,
|
|
actDsId: int = None,
|
|
actDevId: int = None,
|
|
actId: int = None,
|
|
actTimes: int = None,
|
|
actTimeUnit: int = None,
|
|
actTimeDur: int = None,
|
|
actItemId: int = None,
|
|
actRetPos: int = None,
|
|
extUrl: str = None,
|
|
userName: str = None,
|
|
password: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.ActionRule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def download_action_rule(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.ActionRule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DownloadHistory'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def send_data_2_player(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.ActionRule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SendData2Player'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_all_histories_of_action_rule(self, idList: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.ActionRule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DeleteHistory', 'idList': idList}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_action_rules(self, start: str = None, limit: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.ActionRule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List', 'Start': start, 'limit': limit}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def disable_action_rules(self, idList: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.ActionRule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Disable', 'idList': idList}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enable_action_rules(self, idList: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.ActionRule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enable', 'idList': idList}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_history_action_rules(self, start: int = None, limit: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.ActionRule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListHistory', 'start': start, 'limit': limit}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_action_rule(self, idList: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.ActionRule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete', 'idList': idList}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_list_of_emaps(self,
|
|
start: int = None,
|
|
limit: str = None,
|
|
emapIds: int = None,
|
|
includeItems: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Emap'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_specific_emaps_setting(self,
|
|
emapIds: int = None,
|
|
includeImage: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Emap'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Load'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_emap_image(self,
|
|
filename: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Emap.Image'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Load'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_autorized_ds_token(self) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetRegisterToken'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_message_event(self,
|
|
eventTypes: str = None,
|
|
subject: str = None,
|
|
content: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Notification'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetCustomizedMessage'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_message_event(self,
|
|
eventTypes: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Notification'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetCustomizedMessage'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_notification_sender_name(self,
|
|
ss_pkg_name: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Notification'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetVariables'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_notification_sender_name(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Notification'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetVariables'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_advanced_notification_setting(self,
|
|
blSyncDSMNotify: bool = None,
|
|
blCompactMsg: bool = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetAdvSetting'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_advanced_notification_setting(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Notification'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetAdvSetting'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def send_test_mesg_to_primary_secondary_phone(self,
|
|
smsEnable: bool = None,
|
|
smsMethod: int = None,
|
|
smsProvider: str = None,
|
|
userName: str = None,
|
|
password: str = None,
|
|
confirmPassword: str = None,
|
|
primaryPhoneCode: str = None,
|
|
primaryPhonePrefix: str = None,
|
|
secondaryPhoneCode: str = None,
|
|
secondaryPhonePrefix: str = None,
|
|
secondaryPhoneNumber: str = None,
|
|
setMinMessageInterval: bool = None,
|
|
minMessageInterval: int = None,
|
|
hasSysSms: bool = None,
|
|
apiId: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.SMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SendTestMessage'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_setting_notification_sms(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Notification.SMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetSetting'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_sms_service_setting(self,
|
|
smsEnable: bool = None,
|
|
smsMethod: int = None,
|
|
smsProvider: str = None,
|
|
userName: str = None,
|
|
password: str = None,
|
|
confirmPassword: str = None,
|
|
primaryPhoneCode: str = None,
|
|
primaryPhonePrefix: str = None,
|
|
secondaryPhoneCode: str = None,
|
|
secondaryPhonePrefix: str = None,
|
|
secondaryPhoneNumber: str = None,
|
|
setMinMessageInterval: bool = None,
|
|
minMessageInterval: int = None,
|
|
hasSysSms: bool = None,
|
|
apiId: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Notification.SMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetSetting'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def send_test_sms(self,
|
|
attachSnapshot: bool = None,
|
|
enableInterval: bool = None,
|
|
mobileEnable: bool = None,
|
|
msgInterval: str = None,
|
|
primaryEmail: str = None,
|
|
secondaryEmail: str = None,
|
|
synoMailEnable: bool = None,
|
|
mail_recipient: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.SMS'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SendTestMessage'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def send_test_mail(self,
|
|
attachSnapshot: bool = None,
|
|
enableInterval: bool = None,
|
|
mobileEnable: bool = None,
|
|
msgInterval: str = None,
|
|
primaryEmail: str = None,
|
|
secondaryEmail: str = None,
|
|
synoMailEnable: bool = None,
|
|
mail_recipient: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.PushService'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SendVerificationMail'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_mobile_paired_devices(self,
|
|
attachSnapshot: bool = None,
|
|
enableInterval: bool = None,
|
|
mobileEnable: bool = None,
|
|
msgInterval: str = None,
|
|
primaryEmail: str = None,
|
|
secondaryEmail: str = None,
|
|
synoMailEnable: bool = None,
|
|
mail_recipient: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Notification.PushService'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListMobileDevice'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def unpair_device(self,
|
|
targetIds: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Notification.PushService'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetSetting'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_controller_access_schedule(self,
|
|
targetIds: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.Schedule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetAccessControlControllerSchedule'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_camera_alarm_schedule(self,
|
|
cameraId: int = None,
|
|
alarmdx: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.Schedule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetCameraAlarmSchedule'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_sys_dependent_schedule(self,
|
|
eventGroupTypes: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.Schedule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetSystemDependentSchedule'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_batch_schedule(self,
|
|
eventTypes: str = None,
|
|
schedule: Any = None,
|
|
cameraIds: str = None,
|
|
cameraGroupIds: str = None,
|
|
filter: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.Schedule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetBatchSchedule'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_access_ctrl_door_schedule(self,
|
|
doorId: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.Schedule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetAccessControlDoorSchedule'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_camera_schedule(self,
|
|
cameraId: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.Schedule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetCameraSchedule'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_sys_dependent_schedule(self,
|
|
eventType: int = None,
|
|
schedule: Any = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.Schedule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetSystemDependentSchedule'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_controller_access_schedule(self,
|
|
eventType: int = None,
|
|
schedule: Any = None,
|
|
doorId: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.Schedule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetAccessControlSchedule'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_camera_schedule(self,
|
|
eventType: int = None,
|
|
schedule: Any = None,
|
|
cameraId: Any = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.Schedule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetCameraSchedule'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_notification_email_string(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Notification.Email'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetSetting'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_adv_tab_info_filter(self,
|
|
X: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.Email'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Set'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def create_sms_service_provider(self,
|
|
providerName: str = None,
|
|
providerPort: int = None,
|
|
providerUrl: str = None,
|
|
providerTemplate: str = None,
|
|
providerSepChar: str = None,
|
|
providerNeedSSL: bool = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Notification.SMS.ServiceProvider'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Create'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_sms_provider(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Notification.SMS.ServiceProvider'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_sms_service_provider(self,
|
|
providerName: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Notification.SMS.ServiceProvider'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_addson_to_update(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AddOns'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetUpdateInfo'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enable_specific_addon(self,
|
|
service: int = None,
|
|
servicename: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AddOns'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enable'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_specific_addon_update_info(self,
|
|
service: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AddOns'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CheckUpdateInfo'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_specific_addon_info(self,
|
|
service: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AddOns'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetInfo'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_total_addon_info(self) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AddOns'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def update_addon_package(self,
|
|
service: int = None,
|
|
filePath: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AddOns'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Update'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def check_addon_status(self,
|
|
service: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AddOns'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CheckEnableDone'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def disable_addon(self,
|
|
service: int = None,
|
|
serviceName: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AddOns'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Disable'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_addon_autoupdate(self,
|
|
service: int = None,
|
|
BlEnabled: Any = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AddOns'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetAutoUpdate'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_specific_camera_recording_server(self,
|
|
camIdList: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'RecServClear'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_camera_event_analytic(self,
|
|
camIdList: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EventCount'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_selected_events(self,
|
|
dsIdList: str = None,
|
|
idList: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ClearSelected'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_specific_camera_events(self,
|
|
camIdList: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EventCount'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_analytic_history(self,
|
|
camIdList: str = None,
|
|
typeListstring: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_analytic_history_by_filter(self,
|
|
camIdList: str = None,
|
|
dsId: int = None,
|
|
lock: int = None,
|
|
typeList: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'RecServerEnum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def unklock_selected_events(self,
|
|
dsId: int = None,
|
|
idList: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Unlock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_camera_analytic_trigger(self,
|
|
trigCamIdList: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Trigger'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def flush_event_header(self,
|
|
eventId: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EventFlushHeader'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def lock_selected_events(self,
|
|
dsId: int = None,
|
|
idList: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Lock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_analytic_event_from_rec_server(self,
|
|
camIdList: str = None,
|
|
idList: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'RecServerEventCount'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_analytic_settings(self,
|
|
camId: int = None,
|
|
type: int = None,
|
|
showFrame: bool = None,
|
|
showLine: bool = None,
|
|
showVirtualFence: bool = None,
|
|
beep: bool = None,
|
|
sens: int = None,
|
|
dwellTime: int = None,
|
|
direction: int = None,
|
|
objSize: int = None,
|
|
region: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Alert.Setting'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def check_if_snapshot_exist(self,
|
|
id: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ChkFileExist'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_snapshot_modification(self,
|
|
id: int = None,
|
|
createCopy: bool = None,
|
|
width: int = None,
|
|
height: int = None,
|
|
byteSize: int = None,
|
|
imageData: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Edit'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def count_snapshot_by_category(self,
|
|
keyword: str = None,
|
|
dsfrom: int = None,
|
|
to: int = None,
|
|
timezoneOffset: int = None,
|
|
byteSize: int = None,
|
|
imageData: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CountByCategory'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
if key == 'dsfrom':
|
|
req_param[str('from')] = val
|
|
else:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def check_any_locked_snapshot(self,
|
|
id: str = None,
|
|
dsfrom: int = None,
|
|
to: int = None,
|
|
keyword: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ChkContainLocked'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
if key == 'dsfrom':
|
|
req_param[str('from')] = val
|
|
else:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def unlock_snapshot_by_filter(self,
|
|
dsfrom: int = None,
|
|
to: int = None,
|
|
keyword: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'UnlockFiltered'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
if key == 'dsfrom':
|
|
req_param[str('from')] = val
|
|
else:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_snapshot_information(self,
|
|
idList: str = None,
|
|
start: int = None,
|
|
limit: int = None,
|
|
dsfrom: int = None,
|
|
to: int = None,
|
|
keyword: str = None,
|
|
imgSize: int = None,
|
|
blIncludeAuInfo: bool = None,
|
|
blIncludeRecCnt: bool = None,
|
|
camId: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
if key == 'dsfrom':
|
|
req_param[str('from')] = val
|
|
else:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def unlock_snapshot(self,
|
|
objList: Any = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Unlock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def take_snapshot(self,
|
|
dsId: int = None,
|
|
camId: int = None,
|
|
blSave: bool = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'TakeSnapshot'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_snapshot_setting_function(self) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetSetting'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_snapshot_by_filter(self,
|
|
deleteAllCommand: bool = None,
|
|
dsfrom: int = None,
|
|
to: int = None,
|
|
keyword: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DeleteFiltered'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
if key == 'dsfrom':
|
|
req_param[str('from')] = val
|
|
else:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_snapshot_image(self,
|
|
id: int = None,
|
|
imgSize: int = None) -> dict[str, object] | str: # TODO to modify for download?
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'LoadSnapshot'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def lock_snapshot_image(self,
|
|
objList: Any = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Lock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def downld_single_snapshot(self,
|
|
id: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Download'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_new_snapshot_setting(self,
|
|
dispSnapshot: bool = None,
|
|
dispDuration: int = None,
|
|
limitTotalSize: bool = None,
|
|
limitSizeInGb: int = None,
|
|
addTimestamp: bool = None,
|
|
timestampPosition: int = None)-> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SaveSetting'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_snapshot(self,
|
|
camName: str = None,
|
|
createdTm: int = None,
|
|
width: int = None,
|
|
height: int = None,
|
|
byteSize: int = None,
|
|
imageData: str = None)-> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def check_snapshot_status(self,
|
|
dispSnapshot: bool = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.SnapShot'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ChkSnapshotValid'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enable_visualstation(self,
|
|
vslist: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enable'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def update_vs_network_config(self,
|
|
vsMAc: str = None,
|
|
ip: str = None,
|
|
mask: str = None,
|
|
gateway: str = None,
|
|
blDhcp: bool = None,
|
|
name: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ReqNetConfig'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def lock_visualstation_by_id(self,
|
|
vslist: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Lock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enumerate_vs_owner_info(self) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enum'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def unlock_visualstation_by_id(self,
|
|
vslist: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Unlock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def disable_visualstation_by_id(self,
|
|
vslist: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Disable'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_specific_visualstation(self,
|
|
vslist: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enumerate_layout_visualstation(self,
|
|
vsId: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation.Layout'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_layout_information(self,
|
|
id: int = None,
|
|
vsId: int = None,
|
|
name: str = None,
|
|
canGrpId: int = None,
|
|
isDefault: int = None,
|
|
isFixAspectRatio: int = None,
|
|
layoutType: int = None,
|
|
channelList: Any = None,
|
|
customPosList: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation.Layout'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_layout_visualstation(self,
|
|
id: int = None,
|
|
vsId: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation.Layout'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def clear_visualstation_search_result(self) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation.Search'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Start'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_visualstation_ip_info(self,
|
|
ip: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation.Search'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SearchIP'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def stop_previous_visualstation_search(self) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation.Search'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Stop'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_visualstation_list(self,
|
|
offset: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.VisualStation.Layout'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'InfoGet'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_number_of_controller(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetUpdateInfo'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_cardholder_count(self, filterKeyword: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CountByCategoryCardHolder'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enum_all_controllers_logger(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EnumLogConfig'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_cardholder_photo(self,
|
|
photo_name: str = None,
|
|
isRedirectCgi: bool = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetCardholderPhoto'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_log_count(self,
|
|
start: int = None,
|
|
limit: int = None,
|
|
filterType: int = None,
|
|
filterEventSource: Any = None,
|
|
filterSource: int = None,
|
|
filterEventSourceItem: int = None,
|
|
filterTimeFrom: int = None,
|
|
filterTimeTo: int = None,
|
|
filterKeyword: str = None,
|
|
timezoneOffset: int = None,
|
|
doorIds: str = None,
|
|
eventTypes: str = None,
|
|
update: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CountByCategoryLog'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_cardholder_info(self,
|
|
start: int = None,
|
|
limit: int = None,
|
|
filterKeyword: str = None,
|
|
filterStatus: int = None,
|
|
filterCtrlerId: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EnumCardHolder'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def retrieve_last_access_credential(self,
|
|
ctrlerId: int = None,
|
|
idPtId: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'RetrieveLastCard'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enable_disable_controller(self,
|
|
blEnable: bool = None,
|
|
arrayJson: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EnableCtrler'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def acknowledge_all_alarm_level_log(self,
|
|
start: int = None,
|
|
limit: int = None,
|
|
filterEventSource: Any = None,
|
|
filterSource: int = None,
|
|
filterEventSourceItem: str = None,
|
|
filterTimeFrom: int = None,
|
|
filterKeyword: str = None,
|
|
doorIds: str = None,
|
|
eventTypes: str = None,
|
|
update: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'AckAlarm'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def modify_controller_logger_config(self,
|
|
data: Any = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SaveLogConfig'}
|
|
|
|
"""data example:
|
|
|
|
data={"log_evt":"11111111111111111111111111111111111111",
|
|
"id": 97, "log_alarm":"00111111111111111111111111111111111111"}"""
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_controller_settings(self,
|
|
arrayJson: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
"""arrayJson example:
|
|
|
|
arrayJson="[{\"enable\":true,\"id\":97,\"name\":\"ctrler1\",\"host\":\"10.13.12.173\",\"port\":80,
|
|
\"model\":\"A1001\",\"username\":\"root\",\"password\":\"Q__Q-__-\",\"time_server\":
|
|
\"SurveillanceStation\",\"time_zone\":\"Fiji\",\"door\":[{\"id\":231,\"name\":\"FrontDoor\",
|
|
\"enable_cam\":true,\"cam_ds_id\":0,\"cam_id\":13}]}]\" """
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def download_filtered_logs(self,
|
|
start: int = None,
|
|
limit: int = None,
|
|
filterType: int = None,
|
|
filterEventSource: int = None,
|
|
filterSource: int = None,
|
|
filterEventSourceItem: str = None,
|
|
filterTimeFrom: int = None,
|
|
filterTimeTo: int = None,
|
|
filterKeyword: str = None,
|
|
doorIds: str = None,
|
|
eventTypes: str = None,
|
|
update: int = None) -> dict[str, object] | str: # TODO to modify for download?
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DownloadLog'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_door_name_from_controller(self,
|
|
ctrlerId: int = None,
|
|
ip: str = None,
|
|
port: int = None,
|
|
userName: str = None,
|
|
password: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetDoorNames'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def test_connection_and_authentication(self,
|
|
ctrlerId: int = None,
|
|
ip: str = None,
|
|
port: int = None,
|
|
userName: str = None,
|
|
password: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'TestConnect'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enumerate_controller_list_info(self,
|
|
start: int = None,
|
|
limit: int = None,
|
|
update: int = None,
|
|
blIncludeRecCnt: bool = None,
|
|
blIncludeAuInfo: bool = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_cardholder_setting(self,
|
|
arrayJson: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SaveCardHolder'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enumerate_door_info(self,
|
|
DoorIds: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListDoor'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def clear_logs_surveillance_station(self,
|
|
filterType: int = None,
|
|
filterEventSource: Any = None,
|
|
filterSource: int = None,
|
|
filterEventSourceItem: str = None,
|
|
filterTimeFrom: int = None,
|
|
filterTimeTo: int = None,
|
|
filterKeyword: str = None,
|
|
doorIds: str = None,
|
|
eventTypes: str = None,
|
|
update: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ClearLog'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_all_user_privilege(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListPrivilege'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def manual_lock_operation(self,
|
|
doorId: int = None,
|
|
operation: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DoorControl'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_user_door_priv_setting(self,
|
|
arrayJson: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SavePrivilege'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_all_logs(self,
|
|
start: int = None,
|
|
limit: int = None,
|
|
filterType: int = None,
|
|
filterEventSource: Any = None,
|
|
filterSource: int = None,
|
|
filterEventSourceItem: str = None,
|
|
filterTimeFrom: int = None,
|
|
filterTimeTo: int = None,
|
|
filterKeyword: str = None,
|
|
timezoneOffset: int = None,
|
|
doorIds: str = None,
|
|
eventTypes: str = None,
|
|
update: int = None,
|
|
blIncludeRecCnt: bool = None,
|
|
blIncludeAuInfo: bool = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListLog'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_selected_controller(self, ids: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def retrieve_data_from_controller(self, ctrlerId: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Retrieve'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def block_cardholder(self, arrayJson: str = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'BlockCardHolder'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_controller_count(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CountByCategory'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def start_controller_search(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler.Search'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Start'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_controller_search_result(self,
|
|
pid: int = None,
|
|
offset: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.AxisAcsCtrler.Search'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'InfoGet'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enumerate_digital_output(self,
|
|
camId: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.DigitalOutput'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_digital_output_parameters(self,
|
|
camId: int = None,
|
|
idx: int = None,
|
|
keep_setting: bool = None,
|
|
normal_state: int = None,
|
|
trigger_state: bool = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.DigitalOutput'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def long_polling_digital_output_status(self,
|
|
camId: int = None,
|
|
idx: int = None,
|
|
keep: bool = None,
|
|
setNormalCap: bool = None,
|
|
normal: int = None,
|
|
trigger: bool = None,
|
|
timeOut: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.DigitalOutput'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'PollState'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def trigger_external_event(self,
|
|
eventId: int = None,
|
|
eventName: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.ExternalEvent'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Trigger'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_list_io_modules(self,
|
|
start: int = None,
|
|
limit: int = None,
|
|
blFromList: bool = None,
|
|
ownerDsId: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_io_port_list(self,
|
|
Id: int = None,
|
|
Port: int = None,
|
|
IP: str = None,
|
|
User: str = None,
|
|
Pass: str = None,
|
|
Vendor: str = None,
|
|
Model: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EnumPort'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_supported_list_io_modules(self) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EnumVendorModel'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def save_setting_io_module(self,
|
|
name: str = None,
|
|
id: int = None,
|
|
ownerDsId: int = None,
|
|
vendor: str = None,
|
|
model: str = None,
|
|
ip: str = None,
|
|
port: int = None,
|
|
userName: str = None,
|
|
enabled: bool = None,
|
|
status: int = None,
|
|
timeServer: str = None,
|
|
passWord: str = None,
|
|
ntpEnable: bool = None,
|
|
DIOdata: Any = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enable_io_modules(self,
|
|
iomlist: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enable'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def disable_io_modules(self,
|
|
iomlist: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Disable'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_io_modules(self,
|
|
iomlist: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def test_connection_to_io_module(self,
|
|
id: int = None,
|
|
port: str = None,
|
|
ip: str = None,
|
|
userName: str = None,
|
|
passWord: str = None,
|
|
model: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'TestConn'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_capability_io_module(self,
|
|
vendor: str = None,
|
|
model: str = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetCap'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def configure_io_port_setting(self,
|
|
id: int = None,
|
|
DIOdata: Any = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'PortSetting'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def poll_trigger_state_io_module(self,
|
|
Id: int = None,
|
|
list: Any = None,
|
|
timeOut: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'PollingDI'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def poll_do_trigger_module(self,
|
|
id: int = None,
|
|
idx: int = None,
|
|
normal: int = None,
|
|
trigger: bool = None,
|
|
timeOut: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'PollingDO'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_number_of_devices(self) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetDevNumOfDs'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_category_count_io_module(self,
|
|
start: int = None,
|
|
limit: int = None,
|
|
ownerDsId: int = None,
|
|
blFromList: bool = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.IOModule'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CountByCategory'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def start_search_io_module(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.IOModule.Search'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Start'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_search_io_module_info(self,
|
|
pid: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.IOModule.Search'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'InfoGet'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_current_camera_status(self,
|
|
id_list: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Status'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'OneTime'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enum_preset_camera_list(self,
|
|
cameraId: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Preset'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_preset_camera_capability(self,
|
|
cameraId: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Preset'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetInfo'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def record_current_camera_position(self,
|
|
cameraId: int = None,
|
|
position: int = None,
|
|
speed: int = None,
|
|
name: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Preset'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetPreset'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_list_preset_camera(self,
|
|
cameraId: Any = None,
|
|
position: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Preset'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DelPreset'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def go_specific_preset_by_given_speed(self,
|
|
cameraId: Any = None,
|
|
position: int = None,
|
|
speed: int = None,
|
|
type: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Preset'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Execute'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_current_camera_position(self,
|
|
cameraId: Any = None,
|
|
bindPosition: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Preset'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SetHome'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enum_patrol_list(self,
|
|
cam: Any = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Patrol'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enum_patrol_name_list(self,
|
|
camId: Any = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Patrol'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EnumPartial'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def load_patrol_detail(self,
|
|
id: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Patrol'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Load'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def add_or_modify_patrol(self,
|
|
camId: Any = None,
|
|
id: int = None,
|
|
stayTime: int = None,
|
|
speed: int = None,
|
|
name: str = None,
|
|
presetList: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Patrol'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_specific_patrol(self,
|
|
camId: Any = None,
|
|
patrolId: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Patrol'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def run_patrol(self,
|
|
camId: Any = None,
|
|
id: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Patrol'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Execute'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def stop_patrol(self,
|
|
camId: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.PTZ.Patrol'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Stop'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def start_camera_search_process(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Search'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Start'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_camera_search_info(self,
|
|
pid: int = None,
|
|
offset: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Camera.Search'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetInfo'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def toggle_home_mode(self,
|
|
on: bool = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.HomeMode'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Switch'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_home_mode_settings(self,
|
|
need_mobiles: bool = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.HomeMode'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetInfo'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_transaction_list(self,
|
|
filterIds: str = None,
|
|
filterDsIds: str = None,
|
|
filterEnable: bool = None,
|
|
filterStatus: int = None,
|
|
start: int = None,
|
|
limit: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Transactions.Device'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_all_transaction_list(self,
|
|
filterIds: str = None,
|
|
dsId: int = None,
|
|
filterTimeFrom: Any = None,
|
|
filterStatus: int = None,
|
|
filterLock: bool = None,
|
|
filterTimeTo: Any = None,
|
|
filterTimeRangeIntersect: bool = None,
|
|
filterKeyword: str = None,
|
|
start: int = None,
|
|
limit: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Transactions.Transaction'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enum'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def lock_history_records(self,
|
|
filterIds: str = None,
|
|
dsId: int = None,
|
|
filterStatus: int = None,
|
|
filterLock: bool = None,
|
|
filterTimeFrom: Any = None,
|
|
filterTimeTo: Any = None,
|
|
filterTimeRangeIntersect: bool = None,
|
|
filterKeyword: str = None,
|
|
start: int = None,
|
|
limit: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Transactions.Transaction'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Lock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def unlock_history_records(self,
|
|
filterIds: str = None,
|
|
dsId: int = None,
|
|
filterStatus: int = None,
|
|
filterLock: bool = None,
|
|
filterTimeFrom: Any = None,
|
|
filterTimeTo: Any = None,
|
|
filterTimeRangeIntersect: bool = None,
|
|
filterKeyword: str = None,
|
|
start: int = None,
|
|
limit: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Transactions.Transaction'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Unlock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_history_records(self,
|
|
filterIds: str = None,
|
|
dsId: int = None,
|
|
filterStatus: int = None,
|
|
filterLock: bool = None,
|
|
filterTimeFrom: Any = None,
|
|
filterTimeTo: Any = None,
|
|
filterTimeRangeIntersect: bool = None,
|
|
filterKeyword: str = None,
|
|
start: int = None,
|
|
limit: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Transactions.Transaction'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def start_session_with_specified_session_id(self,
|
|
device_name: str = None,
|
|
session_id: str = None,
|
|
timeout: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Transactions.Transaction'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Begin'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def complete_session_with_specified_id(self,
|
|
device_name: str = None,
|
|
session_id: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Transactions.Transaction'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Complete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def cancel_session_with_specified_session_id(self,
|
|
device_name: str = None,
|
|
session_id: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Transactions.Transaction'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Cancel'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def carry_data_into_session_id(self,
|
|
device_name: str = None,
|
|
session_id: str = None,
|
|
content: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Transactions.Transaction'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'AppendData'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def add_edit_active_vault_task(self,
|
|
blCustomFolder: bool = None,
|
|
blLimitBySize: bool = None,
|
|
blRotateFile: bool = None,
|
|
blSrcRecNoOverlap: bool = None,
|
|
blUseRecDet: bool = None,
|
|
camId: Any = None,
|
|
camInfo: Any = None,
|
|
dayLimit: int = None,
|
|
didCode: str = None,
|
|
dsSerial: str = None,
|
|
execTime: Any = None,
|
|
hostname: str = None,
|
|
id: int = None,
|
|
name: str = None,
|
|
passwd: str = None,
|
|
port: str = None,
|
|
recEndTm: Any = None,
|
|
recMode: str = None,
|
|
recSchedule: str = None,
|
|
recStartTm: Any = None,
|
|
schedule: str = None,
|
|
storagePath: str = None,
|
|
type: int = None) -> dict[str, object] | str: # TODO to check
|
|
api_name = 'SYNO.SurveillanceStation.Archiving.Pull'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SaveTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def login_source_server_get_info(self,
|
|
port: str = None,
|
|
hostname: str = None,
|
|
protocol: bool = None,
|
|
username: str = None,
|
|
passwd: str = None,
|
|
archId: int = None,
|
|
didCode: str = None,
|
|
srcDsId: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Archiving.Pull'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'LoginSourceDS'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_archive_vault_task(self,
|
|
id: int = None,
|
|
keepRec: bool = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Archiving.Pull'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DeleteTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_exist_archive_vault(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Archiving.Pull'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enable_archive_vault_task(self,
|
|
id: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Archiving.Pull'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enable'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def disable_archive_vault_task(self,
|
|
id: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Archiving.Pull'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DisableTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def disable_archive_vault_batchedit_task(self,
|
|
taskIds: str = None,
|
|
attrs: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Archiving.Pull'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'BatchEditTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_batch_edit_progress(self,
|
|
pid: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Archiving.Pull'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'BatchEditProgress'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_batchedit_proress_info(self,
|
|
pid: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Archiving.Pull'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetBatchEditProgress'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def clean_batchedit_progress_data(self,
|
|
pid: int = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.Archiving.Pull'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'BatchEditProgressDone'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_youtube_live_broadcast_setting(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.YoutubeLive'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Load'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def set_youtube_live_broadcast_info(self,
|
|
rtmp_path: str = None,
|
|
key: str = None,
|
|
cam_id: int = None,
|
|
stream_profile: int = None,
|
|
live_on: bool = None) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.YoutubeLive'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Save'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def close_youtube_live_broadcast(self) -> dict[str, object] | str:
|
|
api_name = 'SYNO.SurveillanceStation.YoutubeLive'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CloseLive'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_deep_video_analytic(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListTask'}
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def create_edit_DVA_task(self,
|
|
analyze_type: int = None,
|
|
actFromHost: bool = None,
|
|
name: str = None,
|
|
camera_id: int = None,
|
|
enable: bool = None,
|
|
enable_recording: bool = None,
|
|
pre_rec_time: int = None,
|
|
post_rec_time: int = None,
|
|
event_integration: int = None,
|
|
region_type: int = None,
|
|
det_region_cnt: int = None,
|
|
det_region: int = None,
|
|
people_mode: int = None,
|
|
reset_cnt_frequency: int = None,
|
|
reset_weekday: int = None,
|
|
reset_date: int = None,
|
|
reset_time_minute: int = None,
|
|
reset_time_hour: int = None,
|
|
fence_dir_flag: int = None,
|
|
people_display_pos: int = None,
|
|
stream_profile: int = None,
|
|
people_enable_stay_max: bool = None,
|
|
intrusion_detect_target: int = None,
|
|
min_obj_size: Any = None,
|
|
min_obj_size_option: int = None,
|
|
enable_min_duration: int = None,
|
|
people_display_info: int = None,
|
|
people_enter: int = None,
|
|
people_stay_max: int = None,
|
|
people_region: str = None,
|
|
people_hint_pos: str = None,
|
|
blEditMode: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SaveTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_dva_task(self,
|
|
ids: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DeleteTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enable_dva_task(self,
|
|
ids: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EnableTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def disable_dva_task(self,
|
|
ids: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DisableTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def reset_counter_people_counting_task(self,
|
|
taskId: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ResetPplCntCounter'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_people_enter_leave_count(self,
|
|
ids: str = None,
|
|
timeStart: str = None,
|
|
timeEnd: str = None,
|
|
timezone: int = None,
|
|
) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.Report'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetCount'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_people_count_of_day(self,
|
|
ids: str = None,
|
|
interval: int = None,
|
|
intervalUnit: int = None,
|
|
timezone: int = None,
|
|
timestamp: int = None,
|
|
blOccupancy: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.Report'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetReport'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_people_counting_task(self,
|
|
taskList: str = None,
|
|
limit: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_recording_file_of_detection(self,
|
|
slaveDsParam: str = None,
|
|
deleteMethod: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_info_of_task_and_frame(self,
|
|
eventId: int = None,
|
|
taskId: int = None,
|
|
blAlertEvt: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetAnalyticResult'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def lock_recording_file_of_detection(self,
|
|
dsId: int = None,
|
|
idList: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Lock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def unlock_recording_file_of_detection(self,
|
|
dsId: int = None,
|
|
idList: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.Recording'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Unlock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_info_people_counting_task(self) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.TaskGroup'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def create_people_counting_task(self,
|
|
enable: bool = None,
|
|
task_ids: str = None,
|
|
owner_ds_id: int = None,
|
|
name: str = None,
|
|
people_display_info: str = None,
|
|
people_enable_stay_max: int = None,
|
|
reset_cnt_frequency: int = None,
|
|
resert_date: int = None,
|
|
resert_weekday: int = None,
|
|
resert_tome_hour: int = None,
|
|
resert_tome_minute: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.TaskGroup'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Create'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def modify_setting_of_people_counting_task(self,
|
|
enable: bool = None,
|
|
id: int = None,
|
|
task_ids: str = None,
|
|
name: str = None,
|
|
people_display_info: int = None,
|
|
people_enable_max: int = None,
|
|
reset_cnt_frequency: int = None,
|
|
resert_date: int = None,
|
|
resert_weekday: int = None,
|
|
resert_tome_hour: int = None,
|
|
resert_tome_minute: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.TaskGroup'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Edit'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_task_group(self,
|
|
ids: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.TaskGroup'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def start_count_people_task_in_groups(self,
|
|
ids: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.TaskGroup'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Enable'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def stop_count_people_task_in_groups(self,
|
|
ids: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.TaskGroup'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Disable'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_number_counting_task_group(self,
|
|
id: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.TaskGroup'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetPeopleCount'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def lock_recording_file_result(self,
|
|
id: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.IVA.TaskGroup'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ResetPeopleCount'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_face_list_task(self,
|
|
ids: str = None,
|
|
ownerDsId: int = None,
|
|
blOnlyEnableDs: bool = None,
|
|
) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def create_or_edit_task(self,
|
|
id: int = None,
|
|
id_on_rec_server: int = None,
|
|
camera_id: int = None,
|
|
camera_id_on_rec: int = None,
|
|
owner_ds_id: int = None,
|
|
enable: bool = None,
|
|
blEditMode: bool = None,
|
|
stream_profile: int = None,
|
|
name: str = None,
|
|
similarity: float = None,
|
|
allowed_color: int = None,
|
|
allowed_list: Any = None,
|
|
blocked_color: int = None,
|
|
blocked_list: Any = None,
|
|
vip_color: int = None,
|
|
vip_list: Any = None,
|
|
recognized_color: int = None,
|
|
unrecognized_color: int = None,
|
|
deleted: bool = None,
|
|
det_region: str = None,
|
|
det_region_cnt: int = None,
|
|
region_type: int = None,
|
|
display_info: int = None,
|
|
display_type: int = None,
|
|
frame_display_info: int = None,
|
|
enable_min_ogj_size: bool = None,
|
|
min_ogj_size: float = None,
|
|
post_rec_time: int = None,
|
|
pre_rec_time: int = None,
|
|
schedule: str = None,
|
|
scheduleOn: bool = None,
|
|
ignore_bad_quality: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_face_task(self,
|
|
ids: str = None,
|
|
keepRecording: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DeleteTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def enable_task_to_start_detection_recording(self,
|
|
ids: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EnableTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def disable_task_to_stop_detection_recording(self,
|
|
ids: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DisableTask'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_task_with_privilege_to_watch(self,
|
|
ids: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListPlayableTsk'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def create_face_group(self,
|
|
name: str = None,
|
|
description: str = None,
|
|
update_registered_face: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CreateFaceGroup'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def disable_face_grooup(self,
|
|
ids: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DeleteFaceGroup'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def edit_face_group(self,
|
|
name: str = None,
|
|
description: str = None,
|
|
update_registered_face: Any = None,
|
|
id: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EditFaceGroup'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_face_group_list(self,
|
|
id_only: bool = None,
|
|
filter: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListFaceGroup'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def count_face_groups(self,
|
|
filter: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CountFaceGroup'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def detect_faces_image(self,
|
|
image_data: str = None,
|
|
image_size: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DetectImageFace'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def create_registered_face(self,
|
|
account: str = None,
|
|
name: str = None,
|
|
description: str = None,
|
|
image_data: str = None,
|
|
image_size: int = None,
|
|
face: Any = None,
|
|
update_face_group: Any = None,
|
|
captured_face_id: int = None,
|
|
update_unrecognized_captured_face: bool = None,
|
|
append_image_data: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CreateRegisteredFace'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_registered_face(self,
|
|
ids: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DeleteRegisteredFace'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def edit_registered_face(self,
|
|
id: int = None,
|
|
account: str = None,
|
|
name: str = None,
|
|
description: str = None,
|
|
image_data: str = None,
|
|
image_size: int = None,
|
|
face: Any = None,
|
|
update_face_group: Any = None,
|
|
captured_face_id: int = None,
|
|
update_unrecognized_captured_face: bool = None,
|
|
append_image_data: bool = None,
|
|
) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'EditRegisteredFace'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_registered_face(self,
|
|
id_only: bool = None,
|
|
filter: Any = None,
|
|
append_image_data: bool = None,
|
|
) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'ListRegisteredFace'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def count_registered_face(self,
|
|
filter: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'CountRegisteredFace'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def search_registered_face(self,
|
|
keywords: str = None,
|
|
append_image_data: bool = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SearchRegisteredFace'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_face_result_list(self,
|
|
filter: Any = None,
|
|
blIncludeSnapshot: bool = None,
|
|
blIncludeRegisteredFace: bool = None,
|
|
limit: int = None,
|
|
slaveDsParam: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face.Result'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'List'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_face_result(self,
|
|
filter: Any = None,
|
|
slaveDsParam: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face.Result'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Delete'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def lock_face_result(self,
|
|
filter: Any = None,
|
|
slaveDsParam: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face.Result'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Lock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def unlock_face_result(self,
|
|
filter: Any = None,
|
|
slaveDsParam: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face.Result'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Unlock'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_recording_file_of_face_info(self,
|
|
capturedFaceId: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face.Result'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetEventInfo'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def get_recognition_face_information(self,
|
|
taskId: int = None,
|
|
eventId: int = None,
|
|
startTime: int = None,
|
|
endTime: int = None,
|
|
blIncludeRegisteredFace: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face.Result'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'GetAnalyticResult'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def correct_face_result(self,
|
|
id: int = None,
|
|
registered_face_id: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face.Result'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'Correct'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def mark_face_result_as_stranger(self,
|
|
ids: str = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Face.Result'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'MarkAsStranger'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def add_new_bookmark(self,
|
|
id: int = None,
|
|
eventId: int = None,
|
|
cameraId: int = None,
|
|
archId: int = None,
|
|
name: str = None,
|
|
timestamp: Any = None,
|
|
comment: str = None,
|
|
) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording.Bookmark'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'SaveBookmark'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def delete_bookmark(self,
|
|
bookmarkIds: Any = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording.Bookmark'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DeleteBookmark'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|
|
def list_bookmark_detail(self,
|
|
offset: int = None,
|
|
limit: int = None,
|
|
cameraIds: str = None,
|
|
fromTime: int = None,
|
|
toTime: int = None) -> dict[str, object] | str: # TODO not working
|
|
api_name = 'SYNO.SurveillanceStation.Recording.Bookmark'
|
|
info = self.gen_list[api_name]
|
|
api_path = info['path']
|
|
req_param = {'version': info['maxVersion'], 'method': 'DeleteBookmark'}
|
|
|
|
for key, val in locals().items():
|
|
if key not in ['self', 'api_name', 'info', 'api_path', 'req_param']:
|
|
if val is not None:
|
|
req_param[str(key)] = val
|
|
|
|
return self.request_data(api_name, api_path, req_param)
|
|
|