ts-onvif
Version:
Client to ONVIF devices
373 lines • 13.1 kB
JavaScript
;
/**
* Recording ver10 module
* @author Andrew D.Laptev <a.d.laptev@gmail.com>
* @see https://www.onvif.org/ver10/recording.wsdl
*/
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const service_1 = __importDefault(require("./service"));
/**
* Recording service
*/
class Recording extends service_1.default {
constructor(onvif) {
super(onvif, 'recording');
}
static recordingSourceToBuild(source) {
return {
SourceId: source.sourceId,
Name: source.name,
Location: source.location,
Description: source.description,
Address: source.address,
};
}
static recordingConfigurationToBuild(configuration) {
return {
Source: Recording.recordingSourceToBuild(configuration.source),
Content: configuration.content,
MaximumRetentionTime: configuration.maximumRetentionTime,
...(configuration.target && { Target: configuration.target }),
};
}
static trackConfigurationToBuild(configuration) {
return {
TrackType: configuration.trackType,
Description: configuration.description,
};
}
static recordingJobTrackToBuild(track) {
return {
SourceTag: track.sourceTag,
Destination: track.destination,
};
}
static recordingJobSourceToBuild(source) {
const tracks = source.tracks
? Array.isArray(source.tracks)
? source.tracks.map((track) => Recording.recordingJobTrackToBuild(track))
: [Recording.recordingJobTrackToBuild(source.tracks)]
: undefined;
return {
...(source.sourceToken && {
SourceToken: {
Type: source.sourceToken.type,
Token: source.sourceToken.token,
},
}),
...(source.autoCreateReceiver !== undefined && { AutoCreateReceiver: source.autoCreateReceiver }),
...(tracks && { Tracks: tracks.length === 1 ? tracks[0] : tracks }),
...(source.extension && { Extension: source.extension }),
};
}
static recordingJobConfigurationToBuild(configuration) {
const sources = configuration.source
? Array.isArray(configuration.source)
? configuration.source.map((source) => Recording.recordingJobSourceToBuild(source))
: [Recording.recordingJobSourceToBuild(configuration.source)]
: undefined;
return {
...(configuration.scheduleToken !== undefined && { $: { ScheduleToken: configuration.scheduleToken } }),
RecordingToken: configuration.recordingToken,
Mode: configuration.mode,
Priority: configuration.priority,
...(sources && { Source: sources.length === 1 ? sources[0] : sources }),
...(configuration.extension && { Extension: configuration.extension }),
...(configuration.eventFilter && { EventFilter: configuration.eventFilter }),
};
}
static searchScopeToBuild(searchScope) {
return {
...(searchScope.includedSources && {
IncludedSources: searchScope.includedSources.map((source) => ({
Type: source.type,
Token: source.token,
})),
}),
...(searchScope.includedRecordings && {
IncludedRecordings: searchScope.includedRecordings,
}),
...(searchScope.recordingInformationFilter && {
RecordingInformationFilter: searchScope.recordingInformationFilter,
}),
...(searchScope.extension && { Extension: searchScope.extension }),
};
}
static storageDestinationToBuild(storageDestination) {
return {
StorageToken: storageDestination.storageToken,
...(storageDestination.relativePath && {
RelativePath: storageDestination.relativePath,
}),
...(storageDestination.extension && { Extension: storageDestination.extension }),
};
}
/**
* Returns the capabilities of the recording service.
*/
async getServiceCapabilities() {
const response = await this.request({
GetServiceCapabilities: {},
});
return response.getServiceCapabilitiesResponse?.capabilities ?? {};
}
/**
* Create a new recording.
* @param options
*/
async createRecording({ recordingConfiguration }) {
const response = await this.request({
CreateRecording: {
RecordingConfiguration: Recording.recordingConfigurationToBuild(recordingConfiguration),
},
});
return response.createRecordingResponse.recordingToken;
}
/**
* Delete a recording.
* @param options
*/
async deleteRecording({ recordingToken }) {
await this.request({
DeleteRecording: {
RecordingToken: recordingToken,
},
});
}
/**
* Return descriptions of all recordings on the device.
*/
async getRecordings() {
const response = await this.request({ GetRecordings: {} }, { array: ['recordingItem', 'track'] });
return response.getRecordingsResponse.recordingItem ?? [];
}
/**
* Change the configuration of a recording.
* @param options
*/
async setRecordingConfiguration({ recordingToken, recordingConfiguration, }) {
await this.request({
SetRecordingConfiguration: {
RecordingToken: recordingToken,
RecordingConfiguration: Recording.recordingConfigurationToBuild(recordingConfiguration),
},
});
}
/**
* Retrieve the recording configuration for a recording.
* @param options
*/
async getRecordingConfiguration({ recordingToken }) {
const response = await this.request({
GetRecordingConfiguration: {
RecordingToken: recordingToken,
},
});
return response.getRecordingConfigurationResponse.recordingConfiguration;
}
/**
* Return recording options for a recording token.
* @param options
*/
async getRecordingOptions({ recordingToken }) {
const response = await this.request({
GetRecordingOptions: {
RecordingToken: recordingToken,
},
});
return response.getRecordingOptionsResponse.options;
}
/**
* Create a new track within a recording.
* @param options
*/
async createTrack({ recordingToken, trackConfiguration }) {
const response = await this.request({
CreateTrack: {
RecordingToken: recordingToken,
TrackConfiguration: Recording.trackConfigurationToBuild(trackConfiguration),
},
});
return response.createTrackResponse.trackToken;
}
/**
* Remove a track from a recording.
* @param options
*/
async deleteTrack({ recordingToken, trackToken }) {
await this.request({
DeleteTrack: {
RecordingToken: recordingToken,
TrackToken: trackToken,
},
});
}
/**
* Retrieve the configuration for a specific track.
* @param options
*/
async getTrackConfiguration({ recordingToken, trackToken }) {
const response = await this.request({
GetTrackConfiguration: {
RecordingToken: recordingToken,
TrackToken: trackToken,
},
});
return response.getTrackConfigurationResponse.trackConfiguration;
}
/**
* Change the configuration of a track.
* @param options
*/
async setTrackConfiguration({ recordingToken, trackToken, trackConfiguration, }) {
await this.request({
SetTrackConfiguration: {
RecordingToken: recordingToken,
TrackToken: trackToken,
TrackConfiguration: Recording.trackConfigurationToBuild(trackConfiguration),
},
});
}
/**
* Create a new recording job.
* @param options
*/
async createRecordingJob({ jobConfiguration }) {
const response = await this.request({
CreateRecordingJob: {
JobConfiguration: Recording.recordingJobConfigurationToBuild(jobConfiguration),
},
});
return response.createRecordingJobResponse;
}
/**
* Remove a recording job.
* @param options
*/
async deleteRecordingJob({ jobToken }) {
await this.request({
DeleteRecordingJob: {
JobToken: jobToken,
},
});
}
/**
* Return a list of all recording jobs on the device.
*/
async getRecordingJobs() {
const response = await this.request({ GetRecordingJobs: {} }, { array: ['jobItem'] });
return response.getRecordingJobsResponse.jobItem ?? [];
}
/**
* Change the configuration for a recording job.
* @param options
*/
async setRecordingJobConfiguration({ jobToken, jobConfiguration, }) {
const response = await this.request({
SetRecordingJobConfiguration: {
JobToken: jobToken,
JobConfiguration: Recording.recordingJobConfigurationToBuild(jobConfiguration),
},
});
return response.setRecordingJobConfigurationResponse;
}
/**
* Return the current configuration for a recording job.
* @param options
*/
async getRecordingJobConfiguration({ jobToken }) {
const response = await this.request({
GetRecordingJobConfiguration: {
JobToken: jobToken,
},
});
return response.getRecordingJobConfigurationResponse.jobConfiguration;
}
/**
* Change the mode of a recording job.
* @param options
*/
async setRecordingJobMode({ jobToken, mode }) {
await this.request({
SetRecordingJobMode: {
JobToken: jobToken,
Mode: mode,
},
});
}
/**
* Return the state of a recording job.
* @param options
*/
async getRecordingJobState({ jobToken }) {
const response = await this.request({
GetRecordingJobState: {
JobToken: jobToken,
},
});
return response.getRecordingJobStateResponse.state;
}
/**
* Export selected recordings to a storage target.
* @param options
*/
async exportRecordedData(options) {
const response = await this.request({
ExportRecordedData: {
...(options.startPoint !== undefined && { StartPoint: options.startPoint }),
...(options.endPoint !== undefined && { EndPoint: options.endPoint }),
SearchScope: Recording.searchScopeToBuild(options.searchScope),
FileFormat: options.fileFormat,
StorageDestination: Recording.storageDestinationToBuild(options.storageDestination),
},
}, { array: ['fileNames'] });
const exportResponse = response.exportRecordedDataResponse;
return {
operationToken: exportResponse.operationToken,
fileNames: exportResponse.fileNames,
extension: exportResponse.extension,
};
}
/**
* Stop an ExportRecordedData operation.
* @param options
*/
async stopExportRecordedData({ operationToken }) {
const response = await this.request({
StopExportRecordedData: {
OperationToken: operationToken,
},
});
return response.stopExportRecordedDataResponse;
}
/**
* Retrieve the state of an ExportRecordedData operation.
* @param options
*/
async getExportRecordedDataState({ operationToken, }) {
const response = await this.request({
GetExportRecordedDataState: {
OperationToken: operationToken,
},
});
return response.getExportRecordedDataStateResponse;
}
/**
* Request a temporary override of the target segment duration for a recording.
* @param options
*/
async overrideSegmentDuration({ targetSegmentDuration, expiration, recordingConfiguration, }) {
await this.request({
OverrideSegmentDuration: {
TargetSegmentDuration: targetSegmentDuration,
Expiration: expiration,
RecordingConfiguration: recordingConfiguration,
},
});
}
}
exports.default = Recording;
//# sourceMappingURL=recording.js.map