654 lines
20 KiB
JavaScript
654 lines
20 KiB
JavaScript
const utils = require('./utils');
|
|
const Request = require('request');
|
|
const async = require('async');
|
|
const io = require('socket.io-client');
|
|
const Mumble = require('./mumble');
|
|
const currentPath = require('path').dirname(require.main.filename);
|
|
const fs = require('fs');
|
|
const lame = require('lame');
|
|
const Speaker = require('speaker');
|
|
const Resampler = require('libsamplerate.js');
|
|
const chunker = require('stream-chunker');
|
|
const Transform = require('stream').Transform;
|
|
const Throttle = require('stream-throttle').Throttle;
|
|
const chalk = require('chalk');
|
|
const OpusEncoder = require('node-opus').OpusEncoder;
|
|
|
|
const log = require('./utils').log
|
|
|
|
class Asset {
|
|
|
|
constructor(asset, configs, token) {
|
|
|
|
this.id = asset.asset_id;
|
|
this.mumbleHost = null;
|
|
this.mumblePort = null;
|
|
this.murmurUser = null;
|
|
this.murmurPassword = null;
|
|
this.hubAddress = null;
|
|
this.group_id = asset.group_id;
|
|
this.generate_voice = asset.generate_voice || false;
|
|
this.generate_gps = asset.generate_gps || false;
|
|
this.token = token;
|
|
this.configs = configs
|
|
this._processConfigs();
|
|
this.pttEndSuccessfully = false;
|
|
this.assetProps = {};
|
|
this.murmurPassword = '';
|
|
this.endTime = +new Date() + (this.configs.settings.testing_duration * 1000)
|
|
|
|
utils.writeLog(`Creating asset ${this.id}`)
|
|
|
|
// Do async work: Init asset.
|
|
async.waterfall([
|
|
this._getConfiguration.bind(this),
|
|
this._getDataFromApi.bind(this),
|
|
this._checkGroupToJoin.bind(this),
|
|
this._connectToHub.bind(this),
|
|
this._connectToMurmur.bind(this),
|
|
this._register.bind(this),
|
|
this._moveToChannel.bind(this),
|
|
],
|
|
(err, result) => {
|
|
utils.writeLog(`Asset ${this.id} was successfully initialized`)
|
|
|
|
if (err) {
|
|
console.log('err', err)
|
|
utils.writeLog(`Asset ${this.id} was not successfully initialized`, err);
|
|
return;
|
|
}
|
|
|
|
// Start simulating...
|
|
this._start();
|
|
});
|
|
}
|
|
|
|
_processConfigs(callback) {
|
|
let apiConfig = this.configs.api;
|
|
this.apiEndpoint = apiConfig.use_secure ? 'https' : 'http';
|
|
this.apiEndpoint += '://' + apiConfig.host + (apiConfig.port ? (':' + apiConfig.port) : '');
|
|
}
|
|
|
|
_getConfiguration(callback) {
|
|
console.log('_getConfiguration', this.id);
|
|
Request.get(
|
|
this.apiEndpoint + '/asset/' + this.id + '/account',
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${this.token}`
|
|
}
|
|
},
|
|
(error, response, body) => {
|
|
if (!error && (response.statusCode === 200 || response.statusCode === 201)) {
|
|
const bodyObj = JSON.parse(body);
|
|
const data = bodyObj.data;
|
|
// console.log('_getConfiguration', data);
|
|
this.mumbleHost = data.configuration.mumble_address;
|
|
this.mumblePort = data.configuration.voice_rtp_port;
|
|
this.murmurUser = bodyObj.data.configuration.mumble_username;
|
|
this.murmurPassword = bodyObj.data.configuration.mumble_password;
|
|
this.hubAddress = data.configuration.hub_address;
|
|
return callback();
|
|
} else {
|
|
utils.writeLog(`ERROR | _getConfiguration | response ${JSON.stringify(response)} | body: ${JSON.stringify(body)}`)
|
|
utils.writeLog(`ERROR | _getConfiguration | Getting informations about asset ${this.id}`, error);
|
|
utils.writeErrorLog(`ERROR_API | _getConfiguration`);
|
|
return callback(error);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
_checkGroupToJoin(callback) {
|
|
console.log('_checkGroupToJoin', this.id);
|
|
Request.get(
|
|
this.apiEndpoint + '/assets/' + this.id + '/groups',
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${this.token}`
|
|
}
|
|
},
|
|
(error, response, body) => {
|
|
if (!error && (response.statusCode === 200 || response.statusCode === 201)) {
|
|
const bodyObj = JSON.parse(body);
|
|
const data = bodyObj.data.map(group => group.group_id);
|
|
if (data.includes(this.group_id)) {
|
|
utils.writeLog(`Asset ${this.id} have group ${this.group_id}`);
|
|
return callback();
|
|
} else {
|
|
utils.writeLog(`ERROR Asset ${this.id} is not in group ${this.group_id}`);
|
|
return;
|
|
}
|
|
} else {
|
|
utils.writeLog(`_checkGroupToJoin | response ${JSON.stringify(response)} | body: ${JSON.stringify(body)}`)
|
|
utils.writeLog(`ERROR | _checkGroupToJoin | Getting informations about asset ${this.id}`, error);
|
|
utils.writeErrorLog(`ERROR_API | _checkGroupToJoin`);
|
|
return callback(error);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
_getDataFromApi(callback) {
|
|
utils.writeLog(`Get informations about asset ${this.id}`);
|
|
Request.get(
|
|
this.apiEndpoint + '/asset/' + this.id,
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${this.token}`
|
|
}
|
|
},
|
|
(error, response, body) => {
|
|
if (!error && (response.statusCode === 200 || response.statusCode === 201)) {
|
|
let bodyObj = JSON.parse(body);
|
|
this.assetProps = bodyObj.data;
|
|
return this._getGroupsFromApi(callback);
|
|
} else {
|
|
utils.writeLog(`ERROR | _getDataFromApi | Getting informations about asset ${this.id}`, error);
|
|
utils.writeErrorLog(`ERROR_API | _getDataFromApi`);
|
|
return callback(error);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
_getGroupsFromApi(callback) {
|
|
|
|
Request.get(
|
|
this.apiEndpoint + '/asset/ ' + this.id + '/groups',
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${this.token}`
|
|
}
|
|
},
|
|
(error, response, body) => {
|
|
if (!error && (response.statusCode === 200 || response.statusCode === 201)) {
|
|
|
|
let bodyObj = JSON.parse(body);
|
|
|
|
this.groups = bodyObj.data;
|
|
|
|
if (this.group_id) {
|
|
this.groups.forEach((g) => {
|
|
if (g.id === this.group_id) {
|
|
this.groupSipId = g.sip_id;
|
|
this.groupName = g.name;
|
|
}
|
|
});
|
|
} else {
|
|
this.groups.forEach((g) => {
|
|
if (g.is_talk_group && g.monitoring.indexOf(this.id) != -1) {
|
|
this.groupSipId = g.sip_id;
|
|
this.groupName = g.name;
|
|
this.group_id = g.id;
|
|
}
|
|
})
|
|
}
|
|
|
|
if (!this.group_id) {
|
|
utils.writeLog(`Group/Default voice group not found for asset: ${this.group_id}`);
|
|
}
|
|
|
|
utils.writeLog(`Group: ${this.group_id} found for asset: ${this.id}`);
|
|
utils.writeLog(`Informations about asset ${this.id} received | groupId: ${this.group_id} | groupName: ${this.groupName}`);
|
|
return callback();
|
|
} else {
|
|
utils.writeLog(`ERROR | _getGroupsFromApi | Getting informations about asset ${this.id}`, error);
|
|
utils.writeErrorLog(`ERROR_API | _getGroupsFromApi`);
|
|
return callback(error);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
_connectToHub(callback) {
|
|
let options = {rejectUnauthorized: false, secure: true};
|
|
let hub = io(this.hubAddress, options);
|
|
this.hub = hub;
|
|
|
|
// Disconnect event
|
|
hub.on('disconnect', () => {
|
|
utils.writeLog(`Asset ${this.id} disconnected from HUB`);
|
|
});
|
|
|
|
hub.on('connect_timeout', () => {
|
|
utils.writeLog(`Asset ${this.id} connect_timeout from HUB`);
|
|
utils.writeErrorLog(`ERROR_HUB | _connectToHub`);
|
|
});
|
|
|
|
hub.on('connect_error', () => {
|
|
utils.writeLog(`Asset ${this.id} connect_error from HUB`);
|
|
utils.writeErrorLog(`ERROR_HUB | _connectToHub`);
|
|
});
|
|
|
|
hub.once('connect', () => {
|
|
return callback();
|
|
});
|
|
hub.on('connect', () => {
|
|
utils.writeLog(`Asset ${this.id} connected to HUB`);
|
|
this._sendArs();
|
|
});
|
|
|
|
hub.on('ptt-press', data => {
|
|
// this._log('ptt-press received');
|
|
});
|
|
|
|
hub.on('ptt-release', data => {
|
|
// this._log('ptt-release received');
|
|
});
|
|
|
|
hub.on('reload', data => {
|
|
// this._log('reload received');
|
|
});
|
|
}
|
|
|
|
_sendArs() {
|
|
let hub = this.hub;
|
|
if (hub && hub.connected) {
|
|
utils.writeLog(`Asset ${this.id} sending ARS`)
|
|
hub.emit('ars', JSON.stringify({
|
|
ars: true,
|
|
userAgent: 'android',
|
|
asset_id: this.id,
|
|
account_id: this.assetProps.account_id,
|
|
asset_sip_id : this.assetProps.sip_id,
|
|
fake: false
|
|
}));
|
|
}
|
|
}
|
|
|
|
_connectToMurmur(callback) {
|
|
if (!this.group_id) { return callback(); }
|
|
|
|
console.log(`Asset ${this.id} connecting to Murmur`);
|
|
const murmurConnectionDetails = {
|
|
mumbleHost: this.mumbleHost,
|
|
mumblePort: this.mumblePort,
|
|
murmurUser: this.murmurUser,
|
|
murmurPassword: this.murmurPassword
|
|
};
|
|
this.mumble = new Mumble(this.id, murmurConnectionDetails, (err) => {
|
|
if (err) {
|
|
utils.writeLog(`ERROR | _connectToMurmur | Asset ${this.id} Murmur connection error`, err);
|
|
utils.writeErrorLog(`ERROR_MURMUR | _connectToMurmur`);
|
|
return callback(err);
|
|
} else {
|
|
setTimeout(()=> {
|
|
return callback();
|
|
}, 500);
|
|
}
|
|
});
|
|
}
|
|
|
|
_register(callback) {
|
|
console.log(`Asset ${this.id} connecting to Register`);
|
|
Request.post(
|
|
this.apiEndpoint + '/audio/register/' + this.id,
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${this.token}`
|
|
}
|
|
},
|
|
(error, response, body) => {
|
|
if (!error && (response.statusCode === 200 || response.statusCode === 201)) {
|
|
utils.writeLog(`Asset ${this.id} audio registered`);
|
|
return callback();
|
|
} else {
|
|
utils.writeLog(`ERROR | _register | Asset ${this.id} audio registered error`, error);
|
|
utils.writeErrorLog(`ERROR_AUDIO | _register`);
|
|
return callback(error);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
_moveToChannel(callback) {
|
|
console.log(`Asset ${this.id} move to Channel ${this.group_id}`);
|
|
// console.log('_moveToChannel', this.apiEndpoint + '/audio/enter-group/' + this.id + '/' + this.group_id)
|
|
Request.post(
|
|
this.apiEndpoint + '/audio/enter-group/' + this.id + '/' + this.group_id,
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${this.token}`
|
|
}
|
|
},
|
|
(error, response, body) => {
|
|
if (!error && (response.statusCode === 200 || response.statusCode === 201)) {
|
|
let hub = this.hub;
|
|
if (hub && hub.connected) {
|
|
|
|
hub.emit('group-monitoring', JSON.stringify(
|
|
{
|
|
asset_id: this.id,
|
|
asset_sip_id : this.assetProps.sip_id,
|
|
asset_alias : this.assetProps.name,
|
|
request_ptt_groups_status: false,
|
|
group_sip_id: this.groupSipId,
|
|
group_id: this.group_id,
|
|
group_name: this.groupName,
|
|
scan_group_ids: null
|
|
}
|
|
));
|
|
utils.writeLog(`Asset ${this.id} monitoring group ${this.group_id}`)
|
|
if (callback) return callback();
|
|
} else {
|
|
if (callback) return callback('Cannot send group-monitoring: Hub not connected');
|
|
}
|
|
} else {
|
|
utils.writeLog(`ERROR | _moveToChannel | Asset ${this.id} audio enter group error`, error);
|
|
utils.writeErrorLog(`ERROR_AUDIO | _moveToChannel`);
|
|
return callback(error);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
_start() {
|
|
this.generate_voice && this._makePtt(); // Generate voce
|
|
this.generate_gps && this._sendGPS(); // Generate GPS
|
|
this._measuringTestTime(); // Process exit base on this.endTime and current date
|
|
}
|
|
|
|
_measuringTestTime() {
|
|
setInterval(() => {
|
|
if(Date.now() > this.endTime + 18000) {
|
|
process.exit(0)
|
|
}
|
|
}, 1000);
|
|
}
|
|
|
|
_verifyRecorder(callback) {
|
|
console.log(chalk.green(`Check to see if a record was created for the unit id: ${this.id} | name: ${this.assetProps.name}`));
|
|
let startDate = parseInt(this.startTime) - 3000;
|
|
let stopDate = parseInt(+new Date() + 30 * 1000);
|
|
setTimeout(() => { this._getRecord(startDate, stopDate, this.configs); }, 3000);
|
|
}
|
|
|
|
_getRecord(startDate, stopDate, configs) {
|
|
|
|
|
|
console.log(`${this.apiEndpoint}/asset-history/${this.id}/call-history/${startDate}/${stopDate}/10`);
|
|
|
|
// console.log(this.apiEndpoint + `/history-pagination/1/300/${this.id}/${startDate}/${stopDate}/0/0/0/1/null`)
|
|
Request.get(
|
|
`${this.apiEndpoint}/asset-history/${this.id}/call-history/${startDate}/${stopDate}/10`,
|
|
// this.apiEndpoint + `/history-pagination/1/300/${this.id}/${startDate}/${stopDate}/0/0/0/1/null`,
|
|
{
|
|
headers: {
|
|
Authorization: `Bearer ${this.token}`
|
|
}
|
|
},
|
|
(error, response, body) => {
|
|
if(!error && (response.statusCode === 200 || response.statusCode === 201)) {
|
|
let bodyObj = JSON.parse(body);
|
|
// console.log('bodyObj', bodyObj)
|
|
if(bodyObj.data.length > 0) {
|
|
|
|
// Get the latest record
|
|
let latest = { id: 0 }
|
|
bodyObj.data.forEach(e => {
|
|
if(e.id > latest.id) {
|
|
latest = e;
|
|
}
|
|
})
|
|
console.log(chalk.green(`[RECORDER] Record found(${latest.id}) for asset ${this.id} ✓`));
|
|
utils.writeLog(`[RECORDER] Record found(${latest.id}) for asset ${this.id}`)
|
|
} else {
|
|
console.log(chalk.yellow(`[RECORDER] for asset ${this.id} not found`));
|
|
}
|
|
} else {
|
|
utils.writeLog(`ERROR | _getRecord | Error getting record for asset ${this.id} | ${error}`);
|
|
utils.writeErrorLog(`ERROR_RECORDER | _getRecord`);
|
|
}
|
|
let assetIds = configs.assets.ids;
|
|
|
|
this._start();
|
|
|
|
}
|
|
);
|
|
}
|
|
|
|
_makePtt(callback) {
|
|
// Sending group monitoring before we make PTT()
|
|
// Is used for the HUB load test(_moveToChannel is sent anyway after connecting to murmur-register)
|
|
if (this.configs.settings.send_group_monitoring_before_each_call == 'true') {
|
|
this._moveToChannel();
|
|
}
|
|
|
|
// Check hub.
|
|
let hub = this.hub;
|
|
if (!hub || !hub.connected) {
|
|
return callback();
|
|
}
|
|
|
|
// Send ptt-press and wait for it to be accepted.
|
|
this._sendPttPress((isAccepted) => {
|
|
if (!isAccepted) {
|
|
return callback();
|
|
}
|
|
|
|
// Select a random track from sounds.tracks
|
|
this.soundPath = `${currentPath}/sounds/${Math.floor(Math.random() * (this.configs.sounds.tracks.length) + 1)}.mp3`
|
|
|
|
// Ptt accepted. We can send voice.
|
|
// Mp3 read stream.
|
|
var mp3 = fs.createReadStream(this.soundPath);
|
|
mp3.on('error', (e) => {
|
|
utils.writeErrorLog(`Error _makePtt asset ${this.id}`, JSON.stringify(e));
|
|
});
|
|
|
|
mp3.on('data', (data) => {
|
|
|
|
});
|
|
|
|
// Decoded mp3.
|
|
var lameDecoder = mp3
|
|
.pipe(new lame.Decoder)
|
|
.on('data', (data) => {
|
|
|
|
})
|
|
|
|
// On format we continue pipeing in. We need the mp3 format to know what to do next. Eg: To resample the mp3 we need to know the current sample rate.
|
|
.on('format', (format) => {
|
|
|
|
// Create resampler.
|
|
var resampler = new Resampler({
|
|
unsafe: false,
|
|
type: Resampler.Type.ZERO_ORDER_HOLD,
|
|
ratio: 48000 / format.sampleRate,
|
|
channels: format.channels
|
|
})
|
|
|
|
// Create mumble voice stream.
|
|
var voiceStream = this.mumble.client.createVoiceStream(0, format.channels);
|
|
|
|
// Send ptt-release on voice end.
|
|
voiceStream.on('end', () => {
|
|
this.pttEndSuccessfully = true;
|
|
setTimeout(() => {
|
|
this._sendPttRelease();
|
|
if(this.endTime > +new Date()) {
|
|
this._makePtt(callback);
|
|
} else {
|
|
utils.writeLog(`Asset ${this.id} Voice sleeping...`);
|
|
}
|
|
}, 1500); // Hangtime
|
|
});
|
|
|
|
// @TODO: Ugly hack for the voice to work with mp3 (The fix is to remove float32ToInt16 conversion). It is the _transform function from OpusEncoderStream class (mumble-client-codecs-node project).
|
|
voiceStream._readableState.pipes._transform = function(chunk, encoding, callback) {
|
|
if (!this._opus) {
|
|
this._opus = new OpusEncoder(48000, chunk.numberOfChannels);
|
|
}
|
|
|
|
callback(null, {
|
|
target: chunk.target,
|
|
codec: 'Opus',
|
|
frame: this._opus.encode(chunk.pcm),
|
|
position: chunk.position
|
|
});
|
|
}
|
|
|
|
// This is used to slow down the mp3 transmision. Murmur will drop packages that are too early. This will make the mp3 transmision real time, just like it is a microphone stream.
|
|
var throtler = new Transform({
|
|
transform (data, _, callback) {
|
|
setTimeout(() => {
|
|
callback(null, data)
|
|
}, 16 / format.channels)
|
|
},
|
|
readableObjectMode: true
|
|
});
|
|
|
|
// Used for converting buffer to float32. Needed for Murmur.
|
|
const buffer2Float32Array = new Transform({
|
|
transform (data, _, callback) {
|
|
callback(null, new Float32Array(data.buffer, data.byteOffset, data.byteLength / 4))
|
|
},
|
|
readableObjectMode: true
|
|
});
|
|
|
|
// Pipe on.
|
|
lameDecoder
|
|
|
|
// Make 4096 chunks to be like the microphone stream.
|
|
// .pipe(chunker(4096, {flush: true, align: true}))
|
|
|
|
// Resample to 48000 hz.
|
|
.pipe(resampler)
|
|
|
|
// Make 4 * 480 chunks for Murmur purposes.
|
|
.pipe(chunker(4 * 480, {flush: true, align: true}))
|
|
|
|
// Slow down the stream.
|
|
.pipe(throtler)
|
|
|
|
// Convert to float 32.
|
|
.pipe(buffer2Float32Array)
|
|
|
|
// Used for testing in nodejs speaker.
|
|
// .pipe(new Speaker)
|
|
|
|
// Mumble voice stream.
|
|
.pipe(voiceStream);
|
|
});
|
|
})
|
|
}
|
|
|
|
_sendGPS() {
|
|
let hub = this.hub;
|
|
if (hub && hub.connected) {
|
|
let lat = this.configs.settings.gps_lat_start_point;
|
|
let lng = this.configs.settings.gps_lng_start_point;
|
|
const max = this.configs.settings.gps_max_interval;
|
|
const min = this.configs.settings.gps_min_interval;
|
|
|
|
let interval = null;
|
|
if (!this.configs.settings.gps_report_interval) {
|
|
interval = Math.floor(Math.random() * (max - min + 1) + min);
|
|
} else {
|
|
interval = this.configs.settings.gps_report_interval;
|
|
}
|
|
|
|
const now = +new Date();
|
|
if(this.endTime > now) {
|
|
var new_lat = this._randomCoordinates(lat);
|
|
var new_lng = this._randomCoordinates(lng);
|
|
|
|
hub.emit('gps', JSON.stringify(
|
|
{
|
|
unix_time: 1467126677000,
|
|
asset_id: this.assetProps.id,
|
|
asset_sip_id: this.assetProps.sip_id,
|
|
speed_kmh: 16,
|
|
lat: new_lat,
|
|
lng: new_lng,
|
|
accuracy: 20.3,
|
|
activity_type: "driving",
|
|
activity_confidence: 90
|
|
}
|
|
));
|
|
lat = new_lat;
|
|
lng = new_lng;
|
|
setTimeout(() => { this._sendGPS(); }, interval);
|
|
} else {
|
|
utils.writeLog(`Asset ${this.id} GPS sleeping...`);
|
|
}
|
|
}
|
|
}
|
|
|
|
_randomCoordinates(coordinate) {
|
|
if(Math.round(Math.random()) === 0) {
|
|
return parseFloat(parseFloat(coordinate) - parseFloat((Math.random() * (0.01 - 0.005) + 0.005).toFixed(4))).toFixed(6);
|
|
} else {
|
|
return parseFloat(parseFloat(coordinate) + parseFloat((Math.random() * (0.01 - 0.005) + 0.005).toFixed(4))).toFixed(6);
|
|
}
|
|
}
|
|
|
|
_sendPttPress(callback) {
|
|
let hub = this.hub;
|
|
if (hub && hub.connected) {
|
|
|
|
var pttAcceptHandler = (data) => {
|
|
data = JSON.parse(data);
|
|
if (data.asset_id != this.id) {
|
|
return;
|
|
}
|
|
utils.writeLog(`Asset ${this.id} sending PTT-PRESS to group ${this.group_id}`)
|
|
hub.removeListener('ptt-deny', pttDenyHandler);
|
|
callback(true);
|
|
};
|
|
hub.once('ptt-accept', pttAcceptHandler);
|
|
|
|
var pttDenyHandler = (data) => {
|
|
data = JSON.parse(data);
|
|
if (data.asset_id != this.id) {
|
|
return;
|
|
}
|
|
utils.writeLog(`Asset ${this.id} received PTT-DENY`);
|
|
hub.removeListener('ptt-accept', pttAcceptHandler);
|
|
callback(false);
|
|
};
|
|
hub.once('ptt-deny', pttDenyHandler);
|
|
|
|
hub.emit('ptt-press', JSON.stringify(
|
|
{
|
|
destination_group_id: this.group_id,
|
|
destination_group_sip_id: this.groupSipId,
|
|
destination_asset_id: 0,
|
|
destination_asset_sip_id: 0,
|
|
asset_id: this.id,
|
|
asset_sip_id: this.assetProps.sip_id,
|
|
asset_alias : this.assetProps.name,
|
|
priority : this.assetProps.priority,
|
|
portable_asset_id: 0,
|
|
portable_alias: null,
|
|
}
|
|
));
|
|
}
|
|
}
|
|
|
|
_sendPttRelease() {
|
|
let hub = this.hub;
|
|
if (hub && hub.connected) {
|
|
|
|
utils.writeLog(`Asset ${this.id} sending PTT-RELEASE to group ${this.group_id}`);
|
|
hub.emit('ptt-release', JSON.stringify(
|
|
{
|
|
destination_group_id: this.group_id,
|
|
destination_group_sip_id: this.groupSipId,
|
|
destination_asset_id: 0,
|
|
destination_asset_sip_id: 0,
|
|
asset_id: this.id,
|
|
asset_sip_id: this.assetProps.sip_id,
|
|
asset_alias : this.assetProps.name,
|
|
priority : this.assetProps.priority,
|
|
portable_asset_id: 0,
|
|
portable_alias: null,
|
|
}
|
|
));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
module.exports = Asset; |