onvif-nvt-ts
Version:
Wrapper for ONVIF spec to control NVT (Network Video Transitter) devices. Forked and added TypeScript support from onvif-nvt.
895 lines • 42 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const soap_1 = __importDefault(require("../utils/soap"));
const Util = __importStar(require("../utils/util"));
const namespaceAttributes = ['xmlns:tds="http://www.onvif.org/ver10/device/wsdl"'];
/**
* All ONVIF API functions return a Promise.
*
* @param {Error} error The error object.
* @param {string} error.message The error message.
* @param {xml} error.soap Associated SOAP xml that is cause of the error.
* @param {object} error.fault Fault information
* @param {string} error.fault.reason Reason for the error.
* @param {string} error.fault.code Code for the error.
* @param {string} error.fault.detail Details of the error.
* @param {data} data The returned data when there is no error.
*/
/**
* @class
* Provide core functionality for Onvif Device Management.
* <p>
* {@link https://www.onvif.org/onvif/specs/core/ONVIF-Core-Specification-v220.pdf}<br>
* {@link https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl}<br>
* {@link https://www.onvif.org/ver10/events/wsdl/event.wsdl}<br>
* </p>
* <h3>Functions</h3>
* {@link Core#getWsdlUrl},
* {@link Core#getServices},
* {@link Core#getServiceCapabilities},
* {@link Core#getCapabilities},
* {@link Core#getHostname},
* {@link Core#setHostname},
* {@link Core#setHostnameFromDHCP},
* {@link Core#getDNS},
* {@link Core#setDNS},
* {@link Core#getNTP},
* {@link Core#setNTP},
* {@link Core#getDynamicDNS},
* setDynamicDNS,
* {@link Core#getNetworkInterfaces},
* setNetworkInterfaces,
* {@link Core#getNetworkProtocols},
* {@link Core#getNetworkDefaultGateway},
* setNetworkDefaultGateway,
* {@link Core#getZeroConfiguration},
* setZeroConfiguration,
* {@link Core#getIPAddressFilter},
* setIPAddressFilter,
* addIPAddressFilter,
* removeIPAddressFilter,
* {@link Core#getDot11Capabilities},
* {@link Core#getDot11Status},
* {@link Core#scanAvailableDot11Networks},
* {@link Core#getDeviceInformation},
* {@link Core#getSystemUris},
* {@link Core#getSystemBackup},
* restoreSystem,
* startSystemRestore,
* {@link Core#getSystemDateAndTime},
* setSystemDateAndTime,
* setSystemFactoryDefault,
* upgradeSystemFirmware,
* startFirmwareUpgrade,
* {@link Core#getSystemLog},
* {@link Core#getSystemSupportInformation},
* {@link Core#systemReboot},
* {@link Core#getScopes},
* setScopes,
* addScopes,
* removeScopes,
* {@link Core#getGeoLocation},
* setGeoLocation,
* deleteGeoLocation,
* {@link Core#getDiscoveryMode},
* setDiscoveryMode,
* {@link Core#getRemoteDiscoveryMode},
* setRemoteDiscoveryMode,
* {@link Core#getDPAddresses},
* setDPAddresses,
* {@link Core#getAccessPolicy},
* setAccessPolicy
* {@link Core#getUsers},
* createUsers,
* deleteUsers,
* setUser,
* createDot1XConfiguration,
* setDot1XConfiguration,
* {@link Core#getDot1XConfiguration},
* {@link Core#getDot1XConfigurations},
* deleteDot1XConfigurations,
* createCertificate,
* {@link Core#getCertificates},
* {@link Core#getCACertificates},
* {@link Core#getCertificatesStatus},
* setCertificatesStatus,
* getPkcs10Request,
* {@link Core#getClientCertificateMode},
* setClientCertificateMode,
* loadCertificates,
* loadCertificateWithPrivateKey,
* getCertificateInformation,
* loadCACertificates,
* deleteCertificates,
* {@link Core#getRemoteUser},
* setRemoteUser,
* {@link Core#getEndpointReference},
* {@link Core#getRelayOutputs},
* setRelayOutputSettings,
* setRelayOutputState,
* sendAuxiliaryCommand
* <br><br>
* <h3>Overview</h3>
* The Device Service is divided into five different categories: capabilities, network, system, I/O
* and security commands. This set of commands can be used to get information about the
* device capabilities and configurations or to set device configurations. An ONVIF compliant
* device shall support the device management service as specified in [ONVIF DM WSDL]. A
* basic set of operations are required for the device management service, other operations are
* recommended or optional to support. The detailed requirements are listed under the command
* descriptions.
*/
class Core {
constructor() {
this.soap = new soap_1.default();
this.timeDiff = 0;
}
/**
* Call this function directly after instantiating a Core object.
* @param serviceAddress An url object from url package - require('url').
* @param username Optional only if the device does NOT have a user.
* @param password Optional only if the device does NOT have a password.
*/
init(serviceAddress, username, password) {
this.serviceAddress = serviceAddress;
this.username = username;
this.password = password;
}
/**
* Private function for creating a SOAP request.
* @param body The body of the xml.
*/
createRequest(body) {
const soapEnvelope = this.soap.createRequest({
body,
xmlns: namespaceAttributes,
diff: this.timeDiff,
username: this.username,
password: this.password
});
return soapEnvelope;
}
async buildRequest(methodName, xml) {
if (typeof methodName === 'undefined' || methodName === null) {
throw new Error('The "methodName" argument for buildRequest is required.');
}
let errMsg = '';
if ((errMsg = Util.isInvalidValue(methodName, 'string'))) {
throw new Error('The "methodName" argument for buildRequest is invalid:' + errMsg);
}
let soapBody = '';
if (!xml) {
soapBody += `<tds:${methodName}/>`;
}
else {
soapBody += `<tds:${methodName}>`;
soapBody += xml;
soapBody += `</tds:${methodName}>`;
}
const soapEnvelope = this.createRequest(soapBody);
return await this.soap.makeRequest('core', this.serviceAddress, methodName, soapEnvelope);
}
/**
* Returns the onvif device's time difference<br>
* {@link getSystemDateAndTime} must be called first to get an accurate time.
*/
getTimeDiff() {
return this.timeDiff;
}
// ---------------------------------------------
// Core API
// ---------------------------------------------
/**
* It is possible for an endpoint to request a URL that can be used to retrieve the complete
* schema and WSDL definitions of a device. The command gives in return a URL entry point
* where all the necessary product specific WSDL and schema definitions can be retrieved. The
* device shall provide a URL for WSDL and schema download through the GetWsdlUrl
* command.
*/
getWsdlUrl() {
return this.buildRequest('GetWsdlUrl', null);
}
/**
* <strong>+++ I get an 'Action Failed' with Axis cameras. Hikvision works fine.</strong><br>
* Returns a collection of the devices services and possibly their available capabilities. The
* returned capability response message is untyped to allow future addition of services, service
* revisions and service capabilities. All returned service capabilities shall be structured by
* different namespaces which are supported by a device.<br>
* A device shall implement this method if any of the ONVIF compliant services implements the
* GetServiceCapabilities. For making sure about the structure of GetServices response with
* capabilities, please refer to Annex C. Example for GetServices Response with capabilities.<br>
* The version in GetServicesResponse shall contain the specification version number of the
* corresponding service that is implemented by a device.
* @param includeCapability The message contains a request for all services in the device and
* possibly the capabilities for each service. If the Boolean
* IncludeCapability is set, then the response shall include the services
* capabilities.
*/
async getServices(includeCapability) {
let errMsg = '';
if (typeof includeCapability !== 'undefined' && includeCapability !== null) {
if ((errMsg = Util.isInvalidValue(includeCapability, 'boolean'))) {
throw new Error('The "includeCapability" argument for getServices is invalid: ' + errMsg);
}
}
let soapBody = '';
if (typeof includeCapability !== 'undefined' && includeCapability !== null) {
// soapBody += '<tds:IncludeCapability>' + (includeCapability ? 1 : 0) + '</tds:IncludeCapability>'
soapBody += '<tds:IncludeCapability>' + includeCapability + '</tds:IncludeCapability>';
}
return await this.buildRequest('GetServices', soapBody);
}
/**
* <strong>+++ I get an 'Action Failed' with Axis cameras. Hikvision works fine.</strong><br>
* This command returns the capabilities of the device service. The service shall implement this
* method if the device supports the GetServices method.
*/
getServiceCapabilities() {
return this.buildRequest('GetServiceCapabilities');
}
/**
* This method provides a backward compatible interface for the base capabilities. Refer to
* GetServices for a full set of capabilities.<br>
* Annex A describes how to interpret the indicated capability. Apart from the addresses, the
* capabilities only reflect optional functions in this specification.
*/
getCapabilities() {
const soapBody = '<tds:Category>All</tds:Category>';
return this.buildRequest('GetCapabilities', soapBody);
}
/**
* This operation is used by an endpoint to get the hostname from a device. The device shall
* return its hostname configurations through the GetHostname command.
*/
getHostname() {
return this.buildRequest('GetHostname');
}
/**
* This operation sets the hostname on a device. It shall be possible to set the device hostname
* configurations through the SetHostname command. Attention: a call to SetDNS may result in
* overriding a previously set hostname.<br>
* A device shall accept strings formated according to RFC 1123 section 2.1 or alternatively to
* RFC 952, other string shall be considered as invalid strings.<br>
* A device shall try to retrieve the name via DHCP when the HostnameFromDHCP capability is
* set and an empty name string is provided.
* @param name The host name. If Name is an empty string hostname
* should be retrieved from DHCP, otherwise the specified Name
* shall be used.
*/
setHostname(name) {
return this.buildRequest('SetHostname', `<tds:Name>${name || ''}</tds:Name>`);
}
/**
* This operation controls whether the hostname shall be retrieved from DHCP.
* A device shall support this command if support is signalled via the HostnameFromDHCP
* capability. Depending on the device implementation the change may only become effective
* after a device reboot. A device shall accept the command independent whether it is currently
* using DHCP to retrieve its IPv4 address or not. Note that the device is not required to retrieve
* its hostname via DHCP while the device is not using DHCP for retrieving its IP address. In the
* latter case the device may fall back to the statically set hostname.
* @param fromDHCP True if the hostname shall be obtained via DHCP.
*/
async setHostnameFromDHCP(fromDHCP) {
let errMsg = '';
if ((errMsg = Util.isInvalidValue(fromDHCP, 'boolean'))) {
throw new Error('The "fromDHCP" argument for setHostnameFromDHCP is invalid: ' + errMsg);
}
return await this.buildRequest('SetHostnameFromDHCP', `<tds:FromDHCP>${fromDHCP}</tds:FromDHCP>`);
}
/**
* This operation gets the DNS settings from a device. The device shall return its DNS
* configurations through the GetDNS command.
*/
async getDNS() {
const result = await this.buildRequest('GetDNS');
if ('data' in result) {
try {
const di = result.data.DNSInformation;
if (!di.SearchDomain) {
di.SearchDomain = [];
}
else if (!Array.isArray(di.SearchDomain)) {
di.SearchDomain = [di.SearchDomain];
}
if (!di.DNSManual) {
di.DNSManual = [];
}
else if (!Array.isArray(di.DNSManual)) {
di.DNSManual = [di.DNSManual];
}
result.data = di;
}
catch (e) { }
}
return result;
}
/**
* This operation sets the DNS settings on a device. It shall be possible to set the device DNS
* configurations through the SetDNS command.<br>
* It is valid to set the FromDHCP flag while the device is not using DHCP to retrieve its IPv4
* address.
* @param fromDHCP True if the DNS servers are obtained via DHCP.
* @param searchDomain The domain(s) to search if the hostname is not
* fully qualified.
* @param DNSManual A list of manually given DNS servers
*/
async setDNS(fromDHCP, searchDomain, DNSManual) {
let errMsg = '';
if ((errMsg = Util.isInvalidValue(fromDHCP, 'boolean'))) {
throw new Error('The "fromDHCP" argument for setDNS is invalid: ' + errMsg);
}
if (typeof searchDomain !== 'undefined' && searchDomain !== null) {
if ((errMsg = Util.isInvalidValue(searchDomain, 'array', true))) {
throw new Error('The "searchDomain" argument for setDNS is invalid: ' + errMsg);
}
for (let i = 0; i < searchDomain.length; i++) {
if ((errMsg = Util.isInvalidValue(searchDomain[i], 'string'))) {
throw new Error(`A "searchDomain" property was invalid(${searchDomain[i]}): ` + errMsg);
}
}
}
if (typeof DNSManual !== 'undefined' && DNSManual !== null) {
if ((errMsg = Util.isInvalidValue(DNSManual, 'array', true))) {
throw new Error('The "DNSManual" argument for setDNS is invalid: ' + errMsg);
}
for (let i = 0; i < DNSManual.length; i++) {
const d = DNSManual[i];
if ((errMsg = Util.isInvalidValue(d, 'object'))) {
throw new Error(`A "DNSManual" property for setDNS is invalid(${JSON.stringify(d)}): ` + errMsg);
}
const type = d.type;
if ((errMsg = Util.isInvalidValue(type, 'string'))) {
throw new Error('The "type" property for setDNS is invalid: ' + errMsg);
}
if (!type.match(/^(IPv4|IPv6)$/)) {
throw new Error('The "type" value for setDNS is invalid: The value must be either "IPv4" or "IPv6".');
}
if (type === 'IPv4' && (errMsg = Util.isInvalidValue(d.IPv4Address, 'string'))) {
throw new Error('The "IPv4Address" property for setDNS is invalid: ' + errMsg);
}
if (type === 'IPv6' && (errMsg = Util.isInvalidValue(d.IPv6Address, 'string'))) {
throw new Error('The "IPv6Address" property for setDNS is invalid: ' + errMsg);
}
}
}
let soapBody = '';
// soapBody += '<tds:FromDHCP>' + (fromDHCP ? 1 : 0) + '</tds:FromDHCP>'
soapBody += '<tds:FromDHCP>' + fromDHCP + '</tds:FromDHCP>';
if (typeof searchDomain !== 'undefined' && searchDomain !== null) {
searchDomain.forEach(s => {
soapBody += '<tds:SearchDomain>' + s + '</tds:SearchDomain>';
});
}
if (typeof DNSManual !== 'undefined' && DNSManual !== null) {
if (DNSManual.length === 0) {
soapBody += '<tds:DNSManual></tds:DNSManual>';
}
else {
DNSManual.forEach(d => {
soapBody += '<tds:DNSManual>';
soapBody += '<tt:Type>' + d.type + '</tt:Type>';
if (d.type === 'IPv4') {
soapBody += '<tt:IPv4Address>' + d.IPv4Address + '</tt:IPv4Address>';
}
else {
soapBody += '<tt:IPv6Address>' + d.IPv6Address + '</tt:IPv6Address>';
}
soapBody += '</tds:DNSManual>';
});
}
}
return await this.buildRequest('SetDNS', soapBody);
}
/**
* This operation gets the NTP settings from a device. If the device supports NTP, it shall be
* possible to get the NTP server settings through the GetNTP command.
*/
getNTP() {
return this.buildRequest('GetNTP');
}
/**
* This operation sets the NTP settings on a device. If support for NTP is signalled via the NTP
* capability, it shall be possible to set the NTP server settings through the SetNTP command.<br>
* A device shall accept string formated according to RFC 1123 section 2.1, other string shall be
* considered as invalid strings. It is valid to set the FromDHCP flag while the device is not using
* DHCP to retrieve its IPv4 address.<br>
* Changes to the NTP server list shall not affect the clock mode DateTimeType. Use
* SetSystemDateAndTime to activate NTP operation.
* @param fromDHCP True if the NTP servers are obtained via DHCP.
* @param NTPManual A list of manually given NTP servers when they
* not are obtained via DHCP.
*/
async setNTP(fromDHCP, NTPManual) {
let errMsg = '';
if ((errMsg = Util.isInvalidValue(fromDHCP, 'boolean'))) {
throw new Error('The "fromDHCP" argument for setNTP is invalid: ' + errMsg);
}
if (typeof NTPManual !== 'undefined' && NTPManual !== null) {
if ((errMsg = Util.isInvalidValue(NTPManual, 'array', true))) {
throw new Error('The "NTPManual" argument for setNTP is invalid: ' + errMsg);
}
for (let i = 0; i < NTPManual.length; i++) {
const d = NTPManual[i];
if ((errMsg = Util.isInvalidValue(d, 'object'))) {
throw new Error(`A "NTPManual" property for setNTP is invalid(${JSON.stringify(d)}): ` + errMsg);
}
const type = d.type;
if ((errMsg = Util.isInvalidValue(type, 'string'))) {
throw new Error('The "type" property for setNTP is invalid: ' + errMsg);
}
if (!type.match(/^(IPv4|IPv6)$/)) {
throw new Error('The "type" value for setNTP is invalid: The value must be either "IPv4" or "IPv6".');
}
if (type === 'IPv4' && (errMsg = Util.isInvalidValue(d.IPv4Address, 'string'))) {
throw new Error('The "IPv4Address" property for setNTP is invalid: ' + errMsg);
}
if (type === 'IPv6' && (errMsg = Util.isInvalidValue(d.IPv6Address, 'string'))) {
throw new Error('The "IPv6Address" property for setNTP is invalid: ' + errMsg);
}
}
}
let soapBody = '';
// soapBody += '<tds:FromDHCP>' + (fromDHCP ? 1 : 0) + '</tds:FromDHCP>'
soapBody += '<tds:FromDHCP>' + fromDHCP + '</tds:FromDHCP>';
if (typeof NTPManual !== 'undefined' && NTPManual !== null) {
if (NTPManual.length === 0) {
soapBody += '<tds:NTPManual></tds:NTPManual>';
}
else {
NTPManual.forEach(d => {
soapBody += '<tds:NTPManual>';
soapBody += '<tt:Type>' + d.type + '</tt:Type>';
if (d.type === 'IPv4') {
soapBody += '<tt:IPv4Address>' + d.IPv4Address + '</tt:IPv4Address>';
}
else {
soapBody += '<tt:IPv6Address>' + d.IPv6Address + '</tt:IPv6Address>';
}
soapBody += '</tds:NTPManual>';
});
}
}
return await this.buildRequest('SetNTP', soapBody);
}
/**
* This operation gets the dynamic DNS settings from a device. If the device supports dynamic
* DNS as specified in [RFC 2136] and [RFC 4702], it shall be possible to get the type, name
* and TTL through the GetDynamicDNS command
*/
getDynamicDNS() {
return this.buildRequest('GetDynamicDNS');
}
/**
*
* @param type The type of update. There are three possible types: the
* device desires no update (NoUpdate), the device wants the
* DHCP server to update (ServerUpdates) and the device does
* the update itself (ClientUpdates).
* @param name The DNS name in case of the device does the update.
* @param ttl Time to live
*/
async setDynamicDNS(type, name, ttl) {
let errMsg = '';
if ((errMsg = Util.isInvalidValue(type, 'string'))) {
throw new Error('The "type" argument for setDynamicDNS is invalid: ' + errMsg);
}
if (!type.match(/^(NoUpdate|ServerUpdates|ClientUpdates)$/)) {
throw new Error('The "type" value for setDynamicDNS is invalid: The value must be either "IPv4" or "IPv6".');
}
if (typeof name !== 'undefined' && name !== null && (errMsg = Util.isInvalidValue(name, 'string', true))) {
throw new Error('The "name" argument for setDynamicDNS is invalid: ' + errMsg);
}
if (typeof ttl !== 'undefined' && ttl !== null && (errMsg = Util.isInvalidValue(ttl, 'integer'))) {
throw new Error('The "ttl" argument for setDynamicDNS is invalid: ' + errMsg);
}
let soapBody = '';
soapBody += '<tds:SetDynamicDNS>';
soapBody += '<tt:Type>' + type + '</tt:Type>';
if (typeof name !== 'undefined' && name !== null) {
soapBody += '<tt:Name>' + name + '</tt:Name>';
}
if (typeof ttl !== 'undefined' && ttl !== null) {
soapBody += '<tt:TTL>' + ttl + '</tt:TTL>';
}
soapBody += '</tds:SetDynamicDNS>';
const soapEnvelope = this.createRequest(soapBody);
return await this.soap.makeRequest('core', this.serviceAddress, 'SetDynamicDNS', soapEnvelope);
}
/**
* This operation gets the network interface configuration from a device. The device shall support return of network interface configuration settings as defined by the NetworkInterface type through the GetNetworkInterfaces command.
*/
getNetworkInterfaces() {
return this.buildRequest('GetNetworkInterfaces');
}
/**
* This operation gets defined network protocols from a device. The device shall support the GetNetworkProtocols command returning configured network protocols.
*/
getNetworkProtocols() {
return this.buildRequest('GetNetworkProtocols');
}
/**
* This operation gets the default gateway settings from a device. The device shall support the GetNetworkDefaultGateway command returning configured default gateway address(es).
*/
getNetworkDefaultGateway() {
return this.buildRequest('GetNetworkDefaultGateway');
}
/**
* This operation gets the zero-configuration from a device. If the device supports dynamic IP configuration according to [RFC3927], it shall support the return of IPv4 zero configuration address and status through the GetZeroConfiguration command.<br>
* Devices supporting zero configuration on more than one interface shall use the extension to list the additional interface settings.
*/
getZeroConfiguration() {
return this.buildRequest('GetZeroConfiguration');
}
/**
* This operation gets the IP address filter settings from a device. If the device supports device access control based on IP filtering rules (denied or accepted ranges of IP addresses), the device shall support the GetIPAddressFilter command.
*/
getIPAddressFilter() {
return this.buildRequest('GetIPAddressFilter');
}
/**
* This operation returns the IEEE802.11 capabilities. The device shall support this operation.<br>
* <strong>Not all do.</strong>
*/
getDot11Capabilities() {
return this.buildRequest('GetDot11Capabilities');
}
/**
* This operation returns the status of a wireless network interface. The device shall support this command.<br>
* <strong>Not all do.</strong>
* @param {string} interfaceToken Network reference token.
* @param {callback=} callback Optional callback, instead of a Promise.
*/
async getDot11Status(interfaceToken) {
let errMsg = '';
if ((errMsg = Util.isInvalidValue(interfaceToken, 'string'))) {
throw new Error('The "interfaceToken" argument for getDot11Status is invalid: ' + errMsg);
}
let soapBody = '';
soapBody += '<tt:InterfaceToken>' + interfaceToken + '</tt:InterfaceToken>';
return await this.buildRequest('GetDot11Status', soapBody);
}
/**
* This operation returns a lists of the wireless networks in range of the device. A device should
* support this operation. The following status can be returned for each network:
* <ul>
* <li>SSID (shall)</li>
* <li>BSSID (should)</li>
* <li>Authentication and key management suite(s) (should)</li>
* <li>Pair cipher(s) (should)</li>
* <li>Group cipher(s) (should)</li>
* <li>Signal strength (should)</li>
* </ul>
* @param {string} interfaceToken Network reference token.
*/
async scanAvailableDot11Networks(interfaceToken) {
let errMsg = '';
if ((errMsg = Util.isInvalidValue(interfaceToken, 'string'))) {
throw new Error('The "interfaceToken" argument for scanAvailableDot11Networks is invalid: ' + errMsg);
}
const soapBody = '<tt:ReferenceToken>' + interfaceToken + '</tt:ReferenceToken>';
return await this.buildRequest('ScanAvailableDot11Networks', soapBody);
}
/**
* This operation gets device information, such as manufacturer, model and firmware version
* from a device. The device shall support the return of device information through the
* GetDeviceInformation command.
*/
getDeviceInformation() {
return this.buildRequest('GetDeviceInformation');
}
/**
* This operation is used to retrieve URIs from which system information may be downloaded
* using HTTP. URIs may be returned for the following system information:<br>
* <strong>System Logs.</strong> Multiple system logs may be returned, of different types. The exact format of
* the system logs is outside the scope of this specification.<br>
* <strong>Support Information.</strong> This consists of arbitrary device diagnostics information from a device.
* The exact format of the diagnostic information is outside the scope of this specification.<br>
* <strong>System Backup.</strong> The received file is a backup file that can be used to restore the current
* device configuration at a later date. The exact format of the backup configuration file is
* outside the scope of this specification.<br>
* If the device allows retrieval of system logs, support information or system backup data, it
* should make them available via HTTP GET. If it does, it shall support the GetSystemUris
* command.
*/
getSystemUris() {
return this.buildRequest('GetSystemUris');
}
/**
* <i>This interface has been deprecated.</i><br>
* A device shall implement this command if the capability
* SystemBackup is signaled. For a replacement method see section 8.3.2 and 8.3.5.<br>
* This operation retrieves system backup configuration file(s) from a device. The backup is
* returned with reference to a name and mime-type together with binary data. The format of the
* backup configuration data is vendor specific. It is expected that after completion of the restore
* operation the device is working on the same configuration as that of the time the configuration
* was backed up. Note that the configuration of static IP addresses may differ.<br>
* Device vendors may put restrictions on the functionality to be restored. The detailed behavior
* is outside the scope of this specification.<br>
* The backup configuration file(s) are transmitted through MTOM [MTOM].
*/
getSystemBackup() {
return this.buildRequest('GetSystemBackup');
}
/**
* This operation gets the device system date and time.
* The device shall support the return of the daylight
* saving setting and of the manual system date and time
* (if applicable) or indication of NTP time (if applicable)
* through the GetSystemDateAndTime command.<br>
* A device shall provide the UTCDateTime information although
* the item is marked as optional to ensure backward compatibility.<br>
* This is required to be called for devices that
* support the GetSystemDateAndTime SOAP method so
* a time diff can be used in subsequent calls to
* the device.
*/
async getSystemDateAndTime() {
const results = await this.buildRequest('GetSystemDateAndTime');
if ('data' in results) {
const parsed = this.parseGetSystemDateAndTime(results.data);
if (parsed && parsed.date) {
const deviceTime = parsed.date.getTime();
const localTime = new Date().getTime();
this.timeDiff = deviceTime - localTime;
}
}
return results;
}
/**
* Private function
* @param sdt GetSystemDateAndTimeResponse converted to JSON.
*/
parseGetSystemDateAndTime(sdt) {
const s0 = sdt;
if (!s0) {
return null;
}
const s1 = s0.GetSystemDateAndTimeResponse;
if (!s1) {
return null;
}
const s2 = s1.SystemDateAndTime;
if (!s2) {
return null;
}
const type = s2.DateTimeType || '';
let dst = null;
if (s2.DaylightSavings) {
dst = s2.DaylightSavings === 'true';
}
const tz = s2.TimeZone && s2.TimeZone.TZ ? s2.TimeZone.TZ : '';
let date = null;
if (s2.UTCDateTime) {
const udt = s2.UTCDateTime;
const t = udt.Time;
const d = udt.Date;
if (t && d && t.Hour && t.Minute && t.Second && d.Year && d.Month && d.Day) {
date = new Date();
date.setUTCFullYear(parseInt(d.Year, 10));
date.setUTCMonth(parseInt(d.Month, 10) - 1);
date.setUTCDate(parseInt(d.Day, 10));
date.setUTCHours(parseInt(t.Hour, 10));
date.setUTCMinutes(parseInt(t.Minute, 10));
date.setUTCSeconds(parseInt(t.Second, 10));
}
}
const res = {
type: type,
dst: dst,
tz: tz,
date: date
};
return res;
}
/**
* This operation gets a system log from the device. The exact format of the system logs is outside the scope of this standard.
* @param logType Specifies the type of system log to get.
* <ul>
* <li>System: Indicates that a system log is requested.</li>
* <li>Access: Indicates that a access log is requested.</li>
* </ul>
*/
async getSystemLog(logType) {
let errMsg = '';
if ((errMsg = Util.isInvalidValue(logType, 'string'))) {
throw new Error('The "logType" argument for getSystemLog is invalid: ' + errMsg);
}
if (!logType.match(/^(System|Access)$/)) {
throw new Error('The "logType" value for getSystemLog is invalid: The value must be either "System" or "Access".');
}
const soapBody = '<tt:LogType>' + logType + '</tt:LogType>';
return await this.buildRequest('GetSystemLog', soapBody);
}
/**
* This operation gets arbitary device diagnostics information from the device.
*/
getSystemSupportInformation() {
return this.buildRequest('GetSystemSupportInformation');
}
/**
* This operation reboots the device.
* @returns Contains the reboot message from the device (ie: Rebooting in 90 seconds).
*/
systemReboot() {
return this.buildRequest('SystemReboot');
}
/**
* This operation requests the scope parameters of a device. The scope parameters are used in
* the device discovery to match a probe message, see Section 7. The Scope parameters are of
* two different types:
* <ul>
* <li>Fixed</li>
* <li>Configurable</li>
* </ul>
* Fixed scope parameters are permanent device characteristics and cannot be removed
* through the device management interface. The scope type is indicated in the scope list
* returned in the get scope parameters response. A device shall support retrieval of discovery
* scope parameters through the GetScopes command. As some scope parameters are
* mandatory, the device shall return a non-empty scope list in the response.
*/
getScopes() {
return this.buildRequest('GetScopes');
}
/**
* This operation gets the geo location information of a device. A device that signals support for
* GeoLocation via the capability GeoLocationEntities shall support the retrieval of geo location
* information via this command.
*/
getGeoLocation() {
return this.buildRequest('GetGeoLocation');
}
/**
* This operation gets the discovery mode of a device
*/
getDiscoveryMode() {
return this.buildRequest('GetDiscoveryMode');
}
/**
* This operation gets the remote discovery mode of a device. See Section 7.4 for the definition of remote discovery extensions. A device that supports remote discovery shall support retrieval of the remote discovery mode setting through the GetRemoteDiscoveryMode command.
*/
getRemoteDiscoveryMode() {
return this.buildRequest('GetRemoteDiscoveryMode');
}
/**
* This operation gets the remote DP address or addresses from a device. If the device supports remote discovery, as specified in Section 7.4, the device shall support retrieval of the remote DP address(es) through the GetDPAddresses command.
*/
getDPAddresses() {
return this.buildRequest('GetDPAddresses');
}
/**
* Access to different services and sub-sets of services should be subject
* to access control. The WS-Security framework gives the prerequisite for
* end-point authentication. Authorization decisions can then be taken
* using an access security policy. This standard does not mandate any
* particular policy description format or security policy but this is
* up to the device manufacturer or system provider to choose policy and
* policy description format of choice. However, an access policy (in
* arbitrary format) can be requested using this command. If the device
* supports access policy settings based on WS-Security authentication,
* then the device shall support this command.
*/
getAccessPolicy() {
return this.buildRequest('GetAccessPolicy');
}
/**
* This operation lists the registered users and corresponding credentials on a device. The device shall support retrieval of registered device users and their credentials for the user token through the GetUsers command.
*/
getUsers() {
return this.buildRequest('GetUsers');
}
/**
* This operation gets one IEEE 802.1X configuration parameter set from the device by
* specifying the configuration token (Dot1XConfigurationToken).<br>
* The device shall support this command if support for IEEE 802.1X is signaled via the Security
* Dot1X capability.<br>
* Regardless of whether the 802.1X method in the retrieved configuration has a password or
* not, the device shall not include the Password element in the response.
* @param dot1XConfigurationToken Dot1XConfigurationToken [ReferenceToken]
*/
async getDot1XConfiguration(dot1XConfigurationToken) {
let errMsg = '';
if ((errMsg = Util.isInvalidValue(dot1XConfigurationToken, 'string'))) {
throw new Error('The "dot1XConfigurationToken" argument for getDot1XConfiguration is invalid: ' + errMsg);
}
const soapBody = '<tds:Dot1XConfigurationToken>' + dot1XConfigurationToken + '</tds:Dot1XConfigurationToken>';
return await this.buildRequest('GetDot1XConfiguration', soapBody);
}
/**
* This operation gets all the existing IEEE 802.1X configuration parameter sets from the device.<br>
* The device shall respond with all the IEEE 802.1X configurations so that the client can get to
* know how many IEEE 802.1X configurations are existing and how they are configured.<br>
* The device shall support this command if support for IEEE 802.1X is signaled via the Security
* Dot1X capability.<br>
* Regardless of whether the 802.1X method in the retrieved configuration has a password or
* not, the device shall not include the Password element in the response.
*/
getDot1XConfigurations() {
return this.buildRequest('GetDot1XConfigurations');
}
/**
* This operation gets all device server certificates (including self-signed) for the purpose of TLS
* authentication and all device client certificates for the purpose of IEEE 802.1X authentication.<br>
* This command lists only the TLS server certificates and IEEE 802.1X client certificates for the
* device (neither trusted CA certificates nor trusted root certificates). The certificates are
* returned as binary data. A device that supports TLS shall support this command and the
* certificates shall be encoded using ASN.1 [X.681], [X.682], [X.683] DER [X.690] encoding
* rules.
*/
getCertificates() {
return this.buildRequest('GetCertificates');
}
/**
* CA certificates will be loaded into a device and be used for the sake of following two cases.<br>
* The one is for the purpose of TLS client authentication in TLS server function. The other one
* is for the purpose of Authentication Server authentication in IEEE 802.1X function. This
* operation gets all CA certificates loaded into a device. A device that supports either TLS client
* authentication or IEEE 802.1X shall support this command and the returned certificates shall
* be encoded using ASN.1 [X.681], [X.682], [X.683] DER [X.690] encoding rules.
*/
getCACertificates() {
return this.buildRequest('GetCACertificates');
}
/**
* This operation is specific to TLS functionality. This operation gets the status
* (enabled/disabled) of the device TLS server certificates. A device that supports TLS shall
* support this command.
*/
getCertificatesStatus() {
return this.buildRequest('GetCertificatesStatus');
}
/**
* This operation is specific to TLS functionality. This operation gets the status
* (enabled/disabled) of the device TLS client authentication. A device that supports TLS shall
* support this command.
*/
getClientCertificateMode() {
return this.buildRequest('GetClientCertificateMode');
}
/**
* This operation returns the configured remote user (if any). A device that signals support for
* remote user handling via the Security Capability RemoteUserHandling shall support this
* operation. The user is only valid for the WS-UserToken profile or as a HTTP / RTSP user.<br>
* The algorithm to use for deriving the password is described in section 5.12.3.1.
*/
getRemoteUser() {
return this.buildRequest('GetRemoteUser');
}
/**
* A client can ask for the device service endpoint reference address property that can be used
* to derive the password equivalent for remote user operation. The device should support the
* GetEndpointReference command returning the address property of the device service
* endpoint reference.
*/
getEndpointReference() {
return this.buildRequest('GetEndpointReference');
}
/**
* This operation gets a list of all available relay outputs and their settings.
*/
getRelayOutputs() {
return this.buildRequest('GetRelayOutputs');
}
}
exports.default = Core;
//# sourceMappingURL=core.js.map