@wazo/sdk

Wazo's JavaScript Software Development Kit

The Wazo JavaScript Software Development Kit is an API wrapper making it easy for you to communicate with your Wazo server. It allows you to add Wazo functionalities to any JavaScript application you are developing.

Usage

Install / Add

You may install the Wazo JavaScript Software Development Kit to your project one of the following ways:

• npm install @wazo/sdk
• yarn add @wazo/sdk

Content Delivery Networks

Alternatively, you may load the Wazo SDK from a CDN. Use one of the following Content Delivery Networks:

UNPKG

<script src="https://unpkg.com/@wazo/sdk/dist/wazo-sdk.js"></script>

jsDelivr

<script src="https://cdn.jsdelivr.net/npm/@wazo/sdk"></script>

Require / Import

Depending on your preference, you may require or add the Wazo SDK to your own client application one of the following ways:

• const { WazoApiClient } = require('@wazo/sdk');
• import { WazoApiClient } from '@wazo/sdk';

Init

const client = new WazoApiClient({
  server: 'demo.wazo.community', // required string
  agent: null // http(s).Agent instance, allows custom proxy, unsecured https, certificate etc.
});

Log In

client.auth.logIn({
  expiration, // optional integer. Session life in number of seconds. If omitted, defaults to 3600 (an hour).
  username, // required string
  password, // required string
  backend, // optional string. If omitted, defaults to wazo_user
}).then(/* undefined if login failed, or : */{
  metadata: {
    username,
    uuid_tenant_uuid,
    xivo_user_uuid,
    groups,
    xivo_uuid,
    tenants: [{ uuid }],
    auth_id
  },
  token, // should be used for other request
  acls,
  utc_expires_at,
  xivo_uuid,
  issued_at,
  utc_issued_at,
  auth_id,
  expires_at,
  xivo_user_uuid
});
// or
const result = await client.auth.login(/* ... */);

Log Out

client.auth.logOut(token).then(/* ... */);
// or
await client.auth.logOut(token);

Check token

client.auth.checkToken(token).then(valid);
// or
const valid = await client.auth.checkToken(token);

Other auth methods

client.auth.listTenants(token);
client.auth.createTenant(token, name);
client.auth.deleteTenant(token, uuid);
client.auth.listUsers(token);
client.auth.listGroups(token);
client.auth.listPolicies(token);

Application

client.application.calls(token, applicationUuid); // list calls
client.application.hangupCall(token, applicationUuid, callId); // hangup a call
client.application.answerCall(token, applicationUuid, callId, context, exten, autoanswer);  // answer a call
client.application.listNodes(token, applicationUuid); // list nodes
client.application.listCallsNodes(token, applicationUuid, nodeUuid); // list calls in a node
client.application.removeCallNodes(token, applicationUuid, nodeUuid, callId); // remove call from node (no hangup)
client.application.addCallNodes(token, applicationUuid, nodeUuid, callId); // add call in a node
client.application.playCall(token, applicationUuid, callId, language, uri); // play a sound into a call

Confd

client.confd.listUsers(token);
client.confd.getUser(token, userUuid);
client.confd.getUserLineSip(token, userUuid, lineId);
client.confd.listApplications(token);

Accessd

client.accessd.listSubscriptions(token);
client.accessd.createSubscription(token, { productSku, name, startDate, contractDate, autoRenew, term });
client.accessd.getSubscription(token, uuid);
client.accessd.listAuthorizations(token);
client.accessd.getAuthorization(token, uuid);

WebRTCPhone

import { WazoWebRTCClient } from '@wazo/sdk';

const phone = new WazoWebRTCClient({
  displayName: 'From WEB',
  host: 'quintana.wazo.community',
  authorizationUser: lineData.username,
  password: lineData.secret,
  media: {
    audio: boolean,
    video: boolean | document.getElementById('video'), // pointing to a `<video id="video" />` element
    localVideo: boolean | document.getElementById('video'), // pointing to a `<video id="video" />` element
  }
});
// eventName can be on the of events : 
// - transport: `connected`, `disconnected`, `transportError`, `message`, `closed`, `keepAliveDebounceTimeout`
// - webrtc: `registered`, `unregistered`, `registrationFailed`, `invite`, `inviteSent`, `transportCreated`, `newTransaction`, `transactionDestroyed`, `notify`, `outOfDialogReferRequested`, `message`.
phone.on('invite', (session: SIP.sessionDescriptionHandler) => {
  this.currentSession = session;
  // ...
});
// or a wildcard : `*`
phone.on('*', (data: mixed, eventName: string) => {
  
});

phone.call('1234');

Calling a number

phone.call(number: string);

Be notified to a phone call

phone.on('invite', (session: SIP.sessionDescriptionHandler) => {
  this.currentSession = session;
});

Answering a call

phone.answer(session: SIP.sessionDescriptionHandler);

Hangup a call

phone.hangup(session: SIP.sessionDescriptionHandler);

Rejecting a call

phone.reject(session: SIP.sessionDescriptionHandler);

Muting a call

phone.mute(session: SIP.sessionDescriptionHandler);

Umuting a call

phone.unmute(session: SIP.sessionDescriptionHandler);

Holding a call

phone.hold(session: SIP.sessionDescriptionHandler);

Unholding a call

phone.unhold(session: SIP.sessionDescriptionHandler);

Transferring a call

phone.transfert(session: SIP.sessionDescriptionHandler, target: string);

Sending a DTMF tone

phone.sendDTMF(session: SIP.sessionDescriptionHandler, tone: string);

Sending a message

phone.sendDTMF(message: string, destination: string);

Closing the RTC connection

phone.close();

Merging sessions in one conference

phone.merge(sessions: Array<SIP.InviteClientContext>);

Add a session to a conference

phone.addToMerge(session: SIP.InviteClientContext);

Remove a session from a conference

phone.removeFromMerge(session: SIP.InviteClientContext, shouldHold: boolean);
// shouldHold indicate if the session should be held after removed from session

Unmerge a sessions from a conference

phone.unmerge(sessions: Array<SIP.InviteClientContext>)

Wazo Websocket

import { WazoWebSocketClient } from '@wazo/sdk';

const ws = new WazoWebSocket({
  host, // wazo websocket host
  token, // valid Wazo token
});

// eventName can be on the of events here: http://documentation.wazo.community/en/stable/api_sdk/websocket.html
ws.on('eventName', (data: mixed) => {
});

// You can also use a wildcard to catch all events
ws.on('*', (data: mixed, eventName: string) => {
});

ws.connect();

Closing the socket

ws.close();