mirror of
https://github.com/donl/plivo-node.git
synced 2026-05-25 22:07:10 -06:00
1038 lines
34 KiB
JavaScript
1038 lines
34 KiB
JavaScript
import * as _ from "lodash";
|
|
|
|
import {
|
|
PlivoResource,
|
|
PlivoResourceInterface
|
|
} from '../base';
|
|
import {
|
|
extend,
|
|
validate
|
|
} from '../utils/common.js';
|
|
|
|
const clientKey = Symbol();
|
|
const action = 'Call/';
|
|
const idField = 'callUuid';
|
|
|
|
export class CallTransferResponse {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.apiId = params.apiId;
|
|
this.callUuids = params.callUuids;
|
|
this.message = params.message;
|
|
|
|
}
|
|
}
|
|
export class ListAllQueuedCalls {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.apiId = params.id;
|
|
this.calls = params.calls;
|
|
}
|
|
}
|
|
export class ListAllLiveCallResponse {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.apiId = params.id;
|
|
this.callUuid = params.callUuid;
|
|
}
|
|
}
|
|
|
|
export class CreateCallResponse {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.apiId = params.apiId;
|
|
this.message = params.message;
|
|
this.requestUuid = params.requestUuid;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
export class GetQueuedCallResponse {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.apiId = params.apiId;
|
|
this.direction = params.direction;
|
|
this.from = params.from;
|
|
this.callStatus = params.callStatus;
|
|
this.to = params.to;
|
|
this.callerName = params.callerName;
|
|
this.callUuid = params.callUuid;
|
|
this.requestUuid = params.requestUuid;
|
|
}
|
|
}
|
|
|
|
|
|
export class GetLiveCallResponse {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.apiId = params.apiId;
|
|
this.callStatus = params.callStatus;
|
|
this.callUuid = params.callUuid;
|
|
this.callerName = params.callerName;
|
|
this.direction = params.direction;
|
|
this.from = params.from;
|
|
this.requestUuid = params.requestUuid;
|
|
this.sessionStart = params.sessionStart;
|
|
this.to = params.to;
|
|
this.stirVerification = params.stirVerification;
|
|
this.stirAttestation = params.stirAttestation;
|
|
}
|
|
}
|
|
export class RetrieveCallResponse {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.apiId = params.apiId;
|
|
this.answerTime = params.answerTime;
|
|
this.billDuration = params.billDuration;
|
|
this.billedDuration = params.billedDuration;
|
|
this.callDirection = params.callDirection;
|
|
this.callDuration = params.callDuration;
|
|
this.callState = params.callState;
|
|
this.callUuid = params.callUuid;
|
|
this.conferenceUuid = params.conferenceUuid;
|
|
this.endTime = params.endTime;
|
|
this.fromNumber = params.fromNumber;
|
|
this.hangupCauseCode = params.hangupCauseCode;
|
|
this.hangupCauseName = params.hangupCauseName;
|
|
this.hangupSource = params.hangupSource;
|
|
this.initiationTime = params.initiationTime;
|
|
this.parentCallUuid = params.parentCallUuid;
|
|
this.resourceUri = params.resourceUri;
|
|
this.toNumber = params.toNumber;
|
|
this.totalAmount = params.totalAmount;
|
|
this.totalRate = params.totalRate;
|
|
this.stirVerification = params.stirVerification;
|
|
this.stirAttestation = params.stirAttestation
|
|
}
|
|
}
|
|
|
|
export class ListAllCallsResponse {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.answerTime = params.answerTime;
|
|
this.billDuration = params.billDuration;
|
|
this.billedDuration = params.billedDuration;
|
|
this.callDirection = params.callDirection;
|
|
this.callDuration = params.callDuration;
|
|
this.callState = params.callState;
|
|
this.callUuid = params.callUuid;
|
|
this.conferenceUuid = params.conferenceUuid;
|
|
this.endTime = params.endTime;
|
|
this.fromNumber = params.fromNumber;
|
|
this.hangupCauseCode = params.hangupCauseCode;
|
|
this.hangupCauseName = params.hangupCauseName;
|
|
this.hangupSource = params.hangupSource;
|
|
this.initiationTime = params.initiationTime;
|
|
this.parentCallUuid = params.parentCallUuid;
|
|
this.resourceUri = params.resourceUri;
|
|
this.toNumber = params.toNumber;
|
|
this.totalAmount = params.totalAmount;
|
|
this.totalRate = params.totalRate;
|
|
this.stirVerification = params.stirVerification;
|
|
this.stirAttestation = params.stirAttestation
|
|
}
|
|
}
|
|
|
|
export class StartPlayingMusicResponse {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.apiId = params.apiId;
|
|
this.message = params.message;
|
|
}
|
|
}
|
|
|
|
export class StartSpeakingTextResponse {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.apiId = params.apiId;
|
|
this.message = params.message;
|
|
}
|
|
}
|
|
|
|
export class SendDigitsResponse {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.apiId = params.apiId;
|
|
this.message = params.message;
|
|
}
|
|
}
|
|
|
|
export class RecordCallResponse {
|
|
constructor(params) {
|
|
params = params || {};
|
|
this.apiId = params.apiId;
|
|
this.message = params.message;
|
|
this.recordingId = params.recordingId;
|
|
this.url = params.url;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Represents a Call
|
|
* @constructor
|
|
* @param {function} client - make api call
|
|
* @param {object} [data] - data of call
|
|
*/
|
|
export class Call extends PlivoResource {
|
|
constructor(client, data = {}) {
|
|
super(action, Call, idField, client);
|
|
|
|
if (idField in data) {
|
|
this.id = data[idField];
|
|
}
|
|
|
|
extend(this, data);
|
|
this[clientKey] = client;
|
|
}
|
|
|
|
/**
|
|
* hangup call
|
|
* @method
|
|
* @promise {Boolean} return true if call hung up
|
|
* @fail {Error} return Error
|
|
*/
|
|
hangup() {
|
|
let params = {}
|
|
params.isVoiceRequest = 'true';
|
|
return super.delete(params);
|
|
}
|
|
|
|
/**
|
|
* transfer call
|
|
* @method
|
|
* @param {object} params - optional params to transfer a call
|
|
* @param {string} [params.legs] aleg, bleg or both Defaults to aleg. aleg will transfer call_uuid ; bleg will transfer the bridged leg (if found) of call_uuid ; both will transfer call_uuid and bridged leg of call_uuid
|
|
* @param {string} [params.alegUrl] URL to transfer for aleg, if legs is aleg or both, then aleg_url has to be specified.
|
|
* @param {string} [params.alegMethod] HTTP method to invoke aleg_url. Defaults to POST.
|
|
* @param {string} [params.blegUrl] URL to transfer for bridged leg, if legs is bleg or both, then bleg_url has to be specified.
|
|
* @param {string} [params.blegMethod] HTTP method to invoke bleg_url. Defaults to POST.
|
|
* @promise {object} return call object
|
|
* @fail {Error} return Error
|
|
*/
|
|
transfer(params, callUUID) {
|
|
params.isVoiceRequest = 'true';
|
|
let client = this[clientKey];
|
|
let that = this;
|
|
callUUID = typeof callUUID !== 'undefined' ? callUUID : that.callUUID;
|
|
|
|
return new Promise((resolve, reject) => {
|
|
client('POST', action + callUUID + '/', params)
|
|
.then(response => {
|
|
extend(that, response.body);
|
|
if (params.hasOwnProperty('isVoiceRequest')) {
|
|
delete params.isVoiceRequest;
|
|
}
|
|
extend(that, params);
|
|
resolve(new CallTransferResponse(that));
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* record call
|
|
* @method
|
|
* @param {object} params - to record call
|
|
* @promise {object} return PlivoGenericResponse Object
|
|
* @fail {Error} return Error
|
|
*/
|
|
record(params= {}) {
|
|
params.isVoiceRequest = 'true';
|
|
return this.startRecording(params);
|
|
}
|
|
|
|
/**
|
|
* record call
|
|
* @method
|
|
* @param {object} params - to record call
|
|
* @promise {object} return PlivoGenericResponse Object
|
|
* @fail {Error} return Error
|
|
*/
|
|
startRecording(params) {
|
|
let client = this[clientKey];
|
|
return new Promise((resolve, reject) => {
|
|
client('POST', action + this.id + '/Record/', params)
|
|
.then(response => {
|
|
resolve(new RecordCallResponse(response.body, idField));
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* stop recording call
|
|
* @method
|
|
* @param {object} params - to stop recording call
|
|
* @promise {object} return PlivoGenericResponse Object
|
|
* @fail {Error} return Error
|
|
*/
|
|
stopRecording(params= {}) {
|
|
params.isVoiceRequest = 'true';
|
|
return super.executeAction(this.id + '/Record/', 'DELETE', params);
|
|
}
|
|
|
|
/**
|
|
* play music for call
|
|
* @method
|
|
* @param {string} url - url which contains audio to play for call
|
|
* @param {object} optionalParams - to stop recording call
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
playMusic(url, optionalParams) {
|
|
return this.startPlayingMusic(url, optionalParams);
|
|
}
|
|
/**
|
|
* play music for call
|
|
* @method
|
|
* @param {string} url - url which contains audio to play for call
|
|
* @param {object} optionalParams - to stop recording call
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
startPlayingMusic(urls, optionalParams) {
|
|
let params = optionalParams || {};
|
|
params.urls = urls;
|
|
params.isVoiceRequest = 'true';
|
|
|
|
let errors = validate([{
|
|
field: 'urls',
|
|
value: urls,
|
|
validators: ['isRequired', 'isString']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
let client = this[clientKey];
|
|
return new Promise((resolve, reject) => {
|
|
client('POST', action + this.id + '/Play/', params)
|
|
.then(response => {
|
|
resolve(new StartPlayingMusicResponse(response.body, idField));
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* stop playing music for call
|
|
* @method
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
stopPlayingMusic() {
|
|
let params = {}
|
|
params.isVoiceRequest = 'true'
|
|
return super.executeAction(this.id + '/Play/', 'DELETE', params);
|
|
}
|
|
|
|
/**
|
|
* speak text for call
|
|
* @method
|
|
* @param {string} text - text to speak for call
|
|
* @param {object} optionalParams - to speak for call
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
speakText(text, optionalParams) {
|
|
return this.startSpeakingText(text, optionalParams);
|
|
}
|
|
|
|
/**
|
|
* speak text for call
|
|
* @method
|
|
* @param {string} text - text to speak for call
|
|
* @param {object} optionalParams - to speak for call
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
startSpeakingText(text, optionalParams) {
|
|
let errors = validate([{
|
|
field: 'text',
|
|
value: text,
|
|
validators: ['isRequired', 'isString']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
|
|
let params = optionalParams || {};
|
|
params.text = text;
|
|
params.isVoiceRequest = 'true';
|
|
|
|
let client = this[clientKey];
|
|
return new Promise((resolve, reject) => {
|
|
client('POST', action + this.id + '/Speak/', params)
|
|
.then(response => {
|
|
resolve(new StartSpeakingTextResponse(response.body, idField));
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* stop speaking text for call
|
|
* @method
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
stopSpeakingText() {
|
|
let params = {}
|
|
params.isVoiceRequest = 'true';
|
|
return super.executeAction(this.id + '/Speak/', 'DELETE', params);
|
|
}
|
|
|
|
/**
|
|
* Send digits on a call
|
|
* @method
|
|
* @param {number} digits - digits to be send
|
|
* @param {object} optionalParams - to send digits for call
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
sendDigits(digits, optionalParams) {
|
|
let errors = validate([{
|
|
field: 'digits',
|
|
value: digits,
|
|
validators: ['isRequired']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
|
|
let params = optionalParams || {};
|
|
params.digits = digits;
|
|
params.isVoiceRequest = 'true';
|
|
|
|
let client = this[clientKey];
|
|
return new Promise((resolve, reject) => {
|
|
client('POST', action + this.id + '/DTMF/', params)
|
|
.then(response => {
|
|
resolve(new SendDigitsResponse(response.body, idField));
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Hangup a Call Request
|
|
* @method
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
cancel() {
|
|
let params = {};
|
|
params.isVoiceRequest = 'true';
|
|
return super.executeAction('Request/' + this.id + '/', 'DELETE', params, '');
|
|
}
|
|
}
|
|
|
|
const liveCallInterfaceKey = Symbol('liveCallInterface');
|
|
const queuedCallInterfaceKey = Symbol('queuedCallInterface');
|
|
|
|
/**
|
|
* Represents a Call Interface
|
|
* @constructor
|
|
* @param {function} client - make api call
|
|
* @param {object} [data] - data of call
|
|
*/
|
|
export class CallInterface extends PlivoResourceInterface {
|
|
|
|
constructor(client, data = {}) {
|
|
super(action, Call, idField, client);
|
|
extend(this, data);
|
|
|
|
this[clientKey] = client;
|
|
this[liveCallInterfaceKey] = new LiveCallInterface(client);
|
|
this[queuedCallInterfaceKey] = new QueuedCallInterface(client);
|
|
}
|
|
|
|
/**
|
|
* Get A Call Detail
|
|
* @method
|
|
* @param {string} id - call uuid to get information of.
|
|
* @promise {object} returns Call Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
get(id) {
|
|
let errors = validate([{
|
|
field: 'id',
|
|
value: id,
|
|
validators: ['isRequired']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
let params = {}
|
|
params.isVoiceRequest = 'true';
|
|
let client = this[clientKey];
|
|
return new Promise((resolve, reject) => {
|
|
if (action !== '' && !id) {
|
|
reject(new Error(this[idKey] + ' must be set'));
|
|
}
|
|
client('GET', action + (id ? id + '/' : ''), params)
|
|
.then(response => {
|
|
resolve(new RetrieveCallResponse(response.body, client));
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
|
|
}
|
|
|
|
/**
|
|
* Get All Call Detail
|
|
* @method
|
|
* @param {object} params - params to get all call details.
|
|
* @promise {object[]} returns list of Call Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
list(params = {}) {
|
|
params.isVoiceRequest = 'true';
|
|
let client = this[clientKey];
|
|
|
|
return new Promise((resolve, reject) => {
|
|
client('GET', action, params)
|
|
.then(response => {
|
|
let objects = [];
|
|
Object.defineProperty(objects, 'meta', {
|
|
value: response.body.meta,
|
|
enumerable: true
|
|
});
|
|
response.body.objects.forEach(item => {
|
|
objects.push(new ListAllCallsResponse(item, client));
|
|
});
|
|
resolve(objects);
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Create a call
|
|
* @method
|
|
* @param {string} from - The phone number to be used as the caller id (with the country code).For e.g, a USA caller id number could be, 15677654321, with '1' for the country code.
|
|
* @param {string} to - The regular number(s) or sip endpoint(s) to call. Regular number must be prefixed with country code but without the + sign). For e.g, to dial a number in the USA, the number could be, 15677654321, with '1' for the country code. Multiple numbers can be sent by using a delimiter. For e.g. 15677654321<12077657621<12047657621. Sip endpoints must be prefixed with sip: E.g., sip:john1234@phone.plivo.com. To make bulk calls, the delimiter < is used. For example, 15677654321<15673464321<sip:john1234@phone.plivo.com Yes, you can mix regular numbers and sip endpoints.
|
|
* @param {string} answerUrl - The URL invoked by Plivo when the outbound call is answered.
|
|
* @param {object} params - optional params to make a call
|
|
* @param {string} [params.answerUrl] The URL invoked by Plivo when a call executes this application.
|
|
* @param {string} [params.answerMethod] The method used to call the answer_url. Defaults to POST.
|
|
* @param {string} [params.hangupUrl] The URL that is notified by Plivo when the call hangs up.
|
|
* @param {string} [params.hangupMethod] The method used to call the hangup_url. Defaults to POST
|
|
* @param {string} [params.fallbackAnswerUrl] Invoked by Plivo only if answer_url is unavailable or the XML response is invalid. Should contain a XML response.
|
|
* @param {string} [params.fallbackMethod] The method used to call the fallback_answer_url. Defaults to POST.
|
|
* @param {string} [params.callerName] Caller name to use with the call.
|
|
* @param {string} [params.sendDigits] Each 'w' character waits 0.5 second before sending a digit. Each 'W' character waits 1 second before sending a digit. You can also add the tone duration in ms by appending @duration after the string (default duration is 2000 ms). For example, 1w2w3@1000
|
|
* @param {boolean} [params.sendOnPreanswer] If set to true and send_digits is also set, digits are sent when the call is in preanswer state. Defaults to false.
|
|
* @param {number} [params.timeLimit] Schedules the call for hangup at a specified time after the call is answered. Value should be an integer > 0(in seconds).
|
|
* @param {number} [params.hangupOnRing] Schedules the call for hangup at a specified time after the call starts ringing. Value should be an integer >= 0 (in seconds).
|
|
* @param {string} [params.machineDetection] Used to detect if the call has been answered by a machine. The valid values are true and hangup.
|
|
* @param {number} [params.machineDetectionTime] Time allotted to analyze if the call has been answered by a machine. It should be an integer >= 2000 and <= 10000 and the unit is ms. The default value is 5000 ms.
|
|
* @param {string} [params.machineDetectionUrl] A URL where machine detection parameters will be sent by Plivo. This parameter should be used to make machine detection asynchronous
|
|
* @param {string} [params.machineDetectionMethod] The HTTP method which will be used by Plivo to request the machine_detection_url. Defaults to POST.
|
|
* @param {string} [params.sipHeaders] List of SIP headers in the form of 'key=value' pairs, separated by commas.
|
|
* @param {number} [params.ringTimeout] Determines the time in seconds the call should ring. If the call is not answered within the ring_timeout value or the default value of 120s, it is canceled.
|
|
* @param {string} [params.parentCallUuid] The call_uuid of the first leg in an ongoing conference call. It is recommended to use this parameter in scenarios where a member who is already present in the conference intends to add new members by initiating outbound API calls.
|
|
* @param {boolean} [params.errorIfParentNotFound] if set to true and the parent_call_uuid cannot be found, the API request would return an error. If set to false, the outbound call API request will be executed even if the parent_call_uuid is not found. Defaults to false.
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
create(from, to, answerUrl, params = {}) {
|
|
let errors = validate([{
|
|
field: 'from',
|
|
value: from,
|
|
validators: ['isRequired']
|
|
},
|
|
{
|
|
field: 'to',
|
|
value: to,
|
|
validators: ['isRequired']
|
|
},
|
|
{
|
|
field: 'answer_url',
|
|
value: answerUrl,
|
|
validators: ['isRequired']
|
|
}
|
|
]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
params.from = from;
|
|
params.to = _.isArray(to) ? _.join(to, '<') : to;
|
|
params.answer_url = answerUrl;
|
|
params.isVoiceRequest = 'true';
|
|
|
|
let client = this[clientKey];
|
|
return new Promise((resolve, reject) => {
|
|
client('POST', action, params)
|
|
.then(response => {
|
|
resolve(new CreateCallResponse(response.body, idField));
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Hangup A Specific Call
|
|
* @method
|
|
* @param {string} callUUID - call uuid to hangup call
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
hangup(callUUID) {
|
|
let errors = validate([{
|
|
field: 'call_uuid',
|
|
value: callUUID,
|
|
validators: ['isRequired']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
return new Call(this[clientKey], {
|
|
id: callUUID
|
|
}).hangup();
|
|
}
|
|
/**
|
|
* Transfer a Call
|
|
* @method
|
|
* @param {string} callUUID - call uuid to transfer call
|
|
* @param {object} params - optional params to transfer a call
|
|
* @param {string} [params.legs] aleg, bleg or both Defaults to aleg. aleg will transfer call_uuid ; bleg will transfer the bridged leg (if found) of call_uuid ; both will transfer call_uuid and bridged leg of call_uuid
|
|
* @param {string} [params.alegUrl] URL to transfer for aleg, if legs is aleg or both, then aleg_url has to be specified.
|
|
* @param {string} [params.alegMethod] HTTP method to invoke aleg_url. Defaults to POST.
|
|
* @param {string} [params.blegUrl] URL to transfer for bridged leg, if legs is bleg or both, then bleg_url has to be specified.
|
|
* @param {string} [params.blegMethod] HTTP method to invoke bleg_url. Defaults to POST.
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
transfer(callUUID, params) {
|
|
let errors = validate([{
|
|
field: 'call_uuid',
|
|
value: callUUID,
|
|
validators: ['isRequired']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
return new Call(this[clientKey], {
|
|
id: callUUID
|
|
}).transfer(params, callUUID);
|
|
}
|
|
|
|
/**
|
|
* Record a Call
|
|
* @method
|
|
* @param {string} callUUID - call uuid to record call
|
|
* @param {object} optionalParams - optional params to record a call
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
record(callUUID, optionalParams = {}) {
|
|
let errors = validate([{
|
|
field: 'call_uuid',
|
|
value: callUUID,
|
|
validators: ['isRequired']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
return new Call(this[clientKey], {
|
|
id: callUUID
|
|
}).record(optionalParams);
|
|
}
|
|
|
|
/**
|
|
* Stop Recording a Call
|
|
* @method
|
|
* @param {string} callUUID - call uuid to stop recording a call
|
|
* @param {object} optionalParams - optional params to stop recording a call
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
stopRecording(callUUID, optionalParams= {}) {
|
|
let errors = validate([{
|
|
field: 'call_uuid',
|
|
value: callUUID,
|
|
validators: ['isRequired']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
return new Call(this[clientKey], {
|
|
id: callUUID
|
|
}).stopRecording(optionalParams);
|
|
}
|
|
|
|
/**
|
|
* Play a music file
|
|
* @method
|
|
* @param {string} callUUID - call uuid to play music file
|
|
* @param {string} url - A single URL or a list of comma separated URLs linking to an mp3 or wav file.
|
|
* @param {object} optionalParams - optional params to play music file.
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
playMusic(callUUID, urls, optionalParams) {
|
|
let errors = validate([{
|
|
field: 'call_uuid',
|
|
value: callUUID,
|
|
validators: ['isRequired']
|
|
},
|
|
{
|
|
field: 'urls',
|
|
value: urls,
|
|
validators: ['isRequired', 'isString']
|
|
}
|
|
]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
return new Call(this[clientKey], {
|
|
id: callUUID
|
|
}).playMusic(urls, optionalParams);
|
|
}
|
|
|
|
/**
|
|
* Stop Playing a music file
|
|
* @method
|
|
* @param {string} callUUID - call uuid to stop plaing music file
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
stopPlayingMusic(callUUID) {
|
|
let errors = validate([{
|
|
field: 'call_uuid',
|
|
value: callUUID,
|
|
validators: ['isRequired']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
return new Call(this[clientKey], {
|
|
id: callUUID
|
|
}).stopPlayingMusic();
|
|
}
|
|
|
|
/**
|
|
* Speak text during a call
|
|
* @method
|
|
* @param {string} callUUID - call uuid to speak text during a call
|
|
* @param {string} text - text to be played.
|
|
* @param {object} optionalParams - optional params to speak text during a call
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
speakText(callUUID, text, optionalParams) {
|
|
let errors = validate([{
|
|
field: 'call_uuid',
|
|
value: callUUID,
|
|
validators: ['isRequired']
|
|
},
|
|
{
|
|
field: 'text',
|
|
value: text,
|
|
validators: ['isRequired', 'isString']
|
|
}
|
|
]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
return new Call(this[clientKey], {
|
|
id: callUUID
|
|
}).speakText(text, optionalParams);
|
|
}
|
|
|
|
/**
|
|
* Stop Speaking text during a call
|
|
* @method
|
|
* @param {string} callUUID - call uuid to stop speaking text during a call
|
|
* @param {object} optionalParams - optional params to stop speaking text during a call
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
stopSpeakingText(callUUID) {
|
|
let errors = validate([{
|
|
field: 'call_uuid',
|
|
value: callUUID,
|
|
validators: ['isRequired']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
return new Call(this[clientKey], {
|
|
id: callUUID
|
|
}).stopSpeakingText();
|
|
}
|
|
|
|
/**
|
|
* Send digits on a call
|
|
* @method
|
|
* @param {string} callUUID - call uuid to send digits on a call
|
|
* @param {number} digits - digits to be send
|
|
* @param {object} optionalParams - optional params to send digits
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
sendDigits(callUUID, digits, optionalParams) {
|
|
let errors = validate([{
|
|
field: 'call_uuid',
|
|
value: callUUID,
|
|
validators: ['isRequired']
|
|
},
|
|
{
|
|
field: 'digits',
|
|
value: digits,
|
|
validators: ['isRequired']
|
|
}
|
|
]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
return new Call(this[clientKey], {
|
|
id: callUUID
|
|
}).sendDigits(digits, optionalParams);
|
|
}
|
|
|
|
/**
|
|
* Hangup a call request
|
|
* @method
|
|
* @param {string} callUUID - call uuid to send digits on a call
|
|
* @promise {object} returns PlivoGenericResponse Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
cancel(id) {
|
|
let errors = validate([{
|
|
field: 'call_uuid',
|
|
value: id,
|
|
validators: ['isRequired']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
return new Call(this[clientKey], {
|
|
id: id
|
|
}).cancel();
|
|
}
|
|
|
|
listLiveCalls(params) {
|
|
return this[liveCallInterfaceKey].list(params);
|
|
}
|
|
|
|
getLiveCall(id) {
|
|
return this[liveCallInterfaceKey].get(id);
|
|
}
|
|
|
|
listQueuedCalls() {
|
|
return this[queuedCallInterfaceKey].list();
|
|
}
|
|
|
|
getQueuedCall(id) {
|
|
return this[queuedCallInterfaceKey].get(id);
|
|
}
|
|
}
|
|
|
|
export class LiveCallResource extends PlivoResource {
|
|
constructor(client, data = {}) {
|
|
super(action, LiveCallResource, idField, client);
|
|
|
|
if (idField in data) {
|
|
this.id = data[idField];
|
|
}
|
|
|
|
extend(this, data);
|
|
this[clientKey] = client;
|
|
}
|
|
}
|
|
|
|
export class QueuedCallResource extends PlivoResource {
|
|
constructor(client, data = {}) {
|
|
super(action, QueuedCallResource, idField, client);
|
|
|
|
if (idField in data) {
|
|
this.id = data[idField];
|
|
}
|
|
|
|
extend(this, data);
|
|
this[clientKey] = client;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Represents a LiveCall interface
|
|
* @constructor
|
|
* @param {function} client - make api call
|
|
* @param {object} [data] - data of call
|
|
*/
|
|
class LiveCallInterface extends PlivoResourceInterface {
|
|
constructor(client, data = {}) {
|
|
super(action, LiveCallResource, idField, client);
|
|
extend(this, data);
|
|
|
|
this[clientKey] = client;
|
|
}
|
|
|
|
/**
|
|
* Get A Live Call Detail
|
|
* @method
|
|
* @param {string} id - call uuid to get information of.
|
|
* @promise {object} returns LiveCallResource Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
get(id) {
|
|
let errors = validate([{
|
|
field: 'id',
|
|
value: id,
|
|
validators: ['isRequired']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
let client = this[clientKey];
|
|
return new Promise((resolve, reject) => {
|
|
if (action !== '' && !id) {
|
|
reject(new Error(this[idKey] + ' must be set'));
|
|
}
|
|
client('GET', action + id, {
|
|
isVoiceRequest: 'true', status: 'live'
|
|
})
|
|
.then(response => {
|
|
resolve(new GetLiveCallResponse(response.body, client));
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
|
|
//List all Live calls
|
|
list(params) {
|
|
let client = this[clientKey];
|
|
if (params === undefined) {
|
|
params = {}
|
|
}
|
|
params.status = 'live'
|
|
params.isVoiceRequest = 'true';
|
|
return new Promise((resolve, reject) => {
|
|
client('GET', action, params)
|
|
.then(response => {
|
|
let calls = [];
|
|
response.body.calls.forEach(callUuid => {
|
|
calls.push(new LiveCallResource(client, {
|
|
callUuid: callUuid
|
|
}));
|
|
});
|
|
resolve(calls);
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Represents a QueuedCall interface
|
|
* @constructor
|
|
* @param {function} client - make api call
|
|
* @param {object} [data] - data of call
|
|
*/
|
|
class QueuedCallInterface extends PlivoResourceInterface {
|
|
constructor(client, data = {}) {
|
|
super(action, QueuedCallResource, idField, client);
|
|
extend(this, data);
|
|
|
|
this[clientKey] = client;
|
|
}
|
|
|
|
/**
|
|
* Get A Queued Call Detail
|
|
* @method
|
|
* @param {string} id - call uuid to get information of.
|
|
* @promise {object} returns QueuedCallResource Object
|
|
* @fail {Error} returns Error
|
|
*/
|
|
get(id) {
|
|
let errors = validate([{
|
|
field: 'id',
|
|
value: id,
|
|
validators: ['isRequired']
|
|
}]);
|
|
|
|
if (errors) {
|
|
return errors;
|
|
}
|
|
let client = this[clientKey];
|
|
|
|
return new Promise((resolve, reject) => {
|
|
if (action !== '' && !id) {
|
|
reject(new Error(this[idKey] + ' must be set'));
|
|
}
|
|
|
|
client('GET', action + id, {
|
|
isVoiceRequest: 'true', status: 'queued'
|
|
})
|
|
.then(response => {
|
|
resolve(new GetQueuedCallResponse(response.body, client));
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
|
|
|
|
}
|
|
|
|
list() {
|
|
let client = this[clientKey];
|
|
|
|
return new Promise((resolve, reject) => {
|
|
client('GET', action, {
|
|
isVoiceRequest: 'true', status: 'queued'
|
|
})
|
|
.then(response => {
|
|
let calls = [];
|
|
response.body.calls.forEach(callUuid => {
|
|
calls.push(new QueuedCallResource(client, {
|
|
callUuid: callUuid
|
|
}));
|
|
});
|
|
resolve(calls);
|
|
})
|
|
.catch(error => {
|
|
reject(error);
|
|
});
|
|
});
|
|
}
|
|
}
|