ts-onvif
Version:
Client to ONVIF devices
250 lines • 9.45 kB
JavaScript
;
/**
* Search ver10 module
* @author Andrew D.Laptev <a.d.laptev@gmail.com>
* @see https://www.onvif.org/ver10/search.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"));
const toOnvifXMLSchemaObject_1 = require("./utils/toOnvifXMLSchemaObject");
/**
* Search service
* @example
* ```ts
* const summary = await cam.search.getRecordingSummary();
* const token = await cam.search.findRecordings({
* scope: { includedRecordings: ['RecordingToken_1'] },
* keepAliveTime: 'PT10S',
* });
* const results = await cam.search.getRecordingSearchResults({ searchToken: token });
* await cam.search.endSearch({ searchToken: token });
* ```
*/
class Search extends service_1.default {
constructor(onvif) {
super(onvif, 'search');
}
static recordingTokensToBuild(tokens) {
if (!tokens?.length) {
return undefined;
}
return tokens.length === 1 ? tokens[0] : tokens;
}
static searchScopeToBuild(searchScope) {
return {
...(searchScope.includedSources && {
IncludedSources: searchScope.includedSources.map((source) => ({
Type: source.type,
Token: source.token,
})),
}),
...(searchScope.includedRecordings && {
IncludedRecordings: Search.recordingTokensToBuild(searchScope.includedRecordings),
}),
...(searchScope.recordingInformationFilter && {
RecordingInformationFilter: searchScope.recordingInformationFilter,
}),
...(searchScope.extension && { Extension: searchScope.extension }),
};
}
static ptzPositionFilterToBuild(searchFilter) {
return {
MinPosition: (0, toOnvifXMLSchemaObject_1.ptzVectorToBuild)(searchFilter.minPosition),
MaxPosition: (0, toOnvifXMLSchemaObject_1.ptzVectorToBuild)(searchFilter.maxPosition),
EnterOrExit: searchFilter.enterOrExit,
...(searchFilter.extension !== undefined ? { Extension: searchFilter.extension } : {}),
};
}
static metadataFilterToBuild(metadataFilter) {
return {
MetadataStreamFilter: metadataFilter.metadataStreamFilter,
...(metadataFilter.extension !== undefined ? { Extension: metadataFilter.extension } : {}),
};
}
static searchResultsRequestToBuild(options) {
return {
SearchToken: options.searchToken,
...(options.minResults !== undefined && { MinResults: options.minResults }),
...(options.maxResults !== undefined && { MaxResults: options.maxResults }),
...(options.waitTime !== undefined && { WaitTime: options.waitTime }),
};
}
/**
* Returns the capabilities of the search service.
*/
async getServiceCapabilities() {
const response = await this.request({
GetServiceCapabilities: {},
});
return response.getServiceCapabilitiesResponse?.capabilities ?? {};
}
/**
* Returns a summary of recorded data on the device.
*/
async getRecordingSummary(_options = {}) {
const response = await this.request({ GetRecordingSummary: {} });
return response.getRecordingSummaryResponse.summary;
}
/**
* Returns detailed information about a recording.
* @param options
*/
async getRecordingInformation({ recordingToken }) {
const response = await this.request({
GetRecordingInformation: {
RecordingToken: recordingToken,
},
});
return response.getRecordingInformationResponse.recordingInformation;
}
/**
* Returns media attributes valid at a specific point in time.
* @param options
*/
async getMediaAttributes({ recordingTokens, time }) {
const response = await this.request({
GetMediaAttributes: {
...(recordingTokens && {
RecordingTokens: Search.recordingTokensToBuild(recordingTokens),
}),
Time: time,
},
}, { array: ['mediaAttributes'] });
return response.getMediaAttributesResponse.mediaAttributes ?? [];
}
/**
* Starts a search for recordings matching the scope.
* @param options
*/
async findRecordings({ scope, maxMatches, keepAliveTime }) {
const response = await this.request({
FindRecordings: {
Scope: Search.searchScopeToBuild(scope),
...(maxMatches !== undefined && { MaxMatches: maxMatches }),
KeepAliveTime: keepAliveTime,
},
});
return response.findRecordingsResponse.searchToken;
}
/**
* Returns results from a recording search session.
* @param options
*/
async getRecordingSearchResults(options) {
const response = await this.request({
GetRecordingSearchResults: Search.searchResultsRequestToBuild(options),
}, { array: ['recordingInformation'] });
return response.getRecordingSearchResultsResponse.resultList;
}
/**
* Starts a search for events in recorded data.
* @param options
*/
async findEvents({ startPoint, endPoint, scope, searchFilter, includeStartState, maxMatches, keepAliveTime, }) {
const response = await this.request({
FindEvents: {
StartPoint: startPoint,
...(endPoint !== undefined && { EndPoint: endPoint }),
Scope: Search.searchScopeToBuild(scope),
SearchFilter: searchFilter,
IncludeStartState: includeStartState,
...(maxMatches !== undefined && { MaxMatches: maxMatches }),
KeepAliveTime: keepAliveTime,
},
});
return response.findEventsResponse.searchToken;
}
/**
* Returns results from an event search session.
* @param options
*/
async getEventSearchResults(options) {
const response = await this.request({
GetEventSearchResults: Search.searchResultsRequestToBuild(options),
}, { array: ['result'] });
return response.getEventSearchResultsResponse.resultList;
}
/**
* Starts a search for PTZ positions in recorded metadata.
* @param options
*/
async findPTZPosition({ startPoint, endPoint, scope, searchFilter, maxMatches, keepAliveTime, }) {
const response = await this.request({
FindPTZPosition: {
StartPoint: startPoint,
...(endPoint !== undefined && { EndPoint: endPoint }),
Scope: Search.searchScopeToBuild(scope),
SearchFilter: Search.ptzPositionFilterToBuild(searchFilter),
...(maxMatches !== undefined && { MaxMatches: maxMatches }),
KeepAliveTime: keepAliveTime,
},
});
return response.findPTZPositionResponse.searchToken;
}
/**
* Returns results from a PTZ position search session.
* @param options
*/
async getPTZPositionSearchResults(options) {
const response = await this.request({
GetPTZPositionSearchResults: Search.searchResultsRequestToBuild(options),
}, { array: ['result'] });
return response.getPTZPositionSearchResultsResponse.resultList;
}
/**
* Starts a search for metadata in recorded data.
* @param options
*/
async findMetadata({ startPoint, endPoint, scope, metadataFilter, maxMatches, keepAliveTime, }) {
const response = await this.request({
FindMetadata: {
StartPoint: startPoint,
...(endPoint !== undefined && { EndPoint: endPoint }),
Scope: Search.searchScopeToBuild(scope),
MetadataFilter: Search.metadataFilterToBuild(metadataFilter),
...(maxMatches !== undefined && { MaxMatches: maxMatches }),
KeepAliveTime: keepAliveTime,
},
});
return response.findMetadataResponse.searchToken;
}
/**
* Returns results from a metadata search session.
* @param options
*/
async getMetadataSearchResults(options) {
const response = await this.request({
GetMetadataSearchResults: Search.searchResultsRequestToBuild(options),
}, { array: ['result'] });
return response.getMetadataSearchResultsResponse.resultList;
}
/**
* Returns the state of a search session.
* @param options
*/
async getSearchState({ searchToken }) {
const response = await this.request({
GetSearchState: {
SearchToken: searchToken,
},
});
return response.getSearchStateResponse.state;
}
/**
* Ends a search session.
* @param options
*/
async endSearch({ searchToken }) {
const response = await this.request({
EndSearch: {
SearchToken: searchToken,
},
});
return response.endSearchResponse.endpoint;
}
}
exports.default = Search;
//# sourceMappingURL=search.js.map